1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package edu.internet2.middleware.grouperClient.poc;
21
22 import java.io.ByteArrayOutputStream;
23 import java.io.File;
24 import java.io.PrintStream;
25 import java.sql.Timestamp;
26 import java.util.ArrayList;
27 import java.util.Arrays;
28 import java.util.Date;
29 import java.util.List;
30 import java.util.Set;
31 import java.util.regex.Matcher;
32 import java.util.regex.Pattern;
33
34 import junit.textui.TestRunner;
35
36 import org.apache.commons.lang.StringUtils;
37 import org.apache.commons.lang.exception.ExceptionUtils;
38
39 import edu.internet2.middleware.grouper.FieldFinder;
40 import edu.internet2.middleware.grouper.FieldType;
41 import edu.internet2.middleware.grouper.Group;
42 import edu.internet2.middleware.grouper.GroupFinder;
43 import edu.internet2.middleware.grouper.GroupSave;
44 import edu.internet2.middleware.grouper.GroupType;
45 import edu.internet2.middleware.grouper.GroupTypeFinder;
46 import edu.internet2.middleware.grouper.GrouperSession;
47 import edu.internet2.middleware.grouper.Member;
48 import edu.internet2.middleware.grouper.MemberFinder;
49 import edu.internet2.middleware.grouper.Membership;
50 import edu.internet2.middleware.grouper.MembershipFinder;
51 import edu.internet2.middleware.grouper.Stem;
52 import edu.internet2.middleware.grouper.StemFinder;
53 import edu.internet2.middleware.grouper.StemSave;
54 import edu.internet2.middleware.grouper.SubjectFinder;
55 import edu.internet2.middleware.grouper.attr.AttributeDef;
56 import edu.internet2.middleware.grouper.attr.AttributeDefName;
57 import edu.internet2.middleware.grouper.attr.AttributeDefNameSave;
58 import edu.internet2.middleware.grouper.attr.AttributeDefNameTest;
59 import edu.internet2.middleware.grouper.attr.AttributeDefSave;
60 import edu.internet2.middleware.grouper.attr.AttributeDefTest;
61 import edu.internet2.middleware.grouper.attr.AttributeDefType;
62 import edu.internet2.middleware.grouper.attr.AttributeDefValueType;
63 import edu.internet2.middleware.grouper.attr.assign.AttributeAssign;
64 import edu.internet2.middleware.grouper.attr.assign.AttributeAssignResult;
65 import edu.internet2.middleware.grouper.attr.finder.AttributeDefFinder;
66 import edu.internet2.middleware.grouper.attr.finder.AttributeDefNameFinder;
67 import edu.internet2.middleware.grouper.cfg.GrouperConfig;
68 import edu.internet2.middleware.grouper.changeLog.ChangeLogTempToEntity;
69 import edu.internet2.middleware.grouper.externalSubjects.ExternalSubject;
70 import edu.internet2.middleware.grouper.externalSubjects.ExternalSubjectSave;
71 import edu.internet2.middleware.grouper.group.TypeOfGroup;
72 import edu.internet2.middleware.grouper.helper.GroupHelper;
73 import edu.internet2.middleware.grouper.helper.GrouperTest;
74 import edu.internet2.middleware.grouper.helper.SessionHelper;
75 import edu.internet2.middleware.grouper.helper.SubjectTestHelper;
76 import edu.internet2.middleware.grouper.internal.dao.QueryOptions;
77 import edu.internet2.middleware.grouper.messaging.GrouperBuiltinMessagingSystem;
78 import edu.internet2.middleware.grouper.misc.CompositeType;
79 import edu.internet2.middleware.grouper.misc.SaveMode;
80 import edu.internet2.middleware.grouper.permissions.role.Role;
81 import edu.internet2.middleware.grouper.privs.AccessPrivilege;
82 import edu.internet2.middleware.grouper.privs.AttributeDefPrivilege;
83 import edu.internet2.middleware.grouper.privs.NamingPrivilege;
84 import edu.internet2.middleware.grouper.util.GrouperUtil;
85 import edu.internet2.middleware.grouper.ws.util.RestClientSettings;
86 import edu.internet2.middleware.grouperClient.GrouperClient;
87 import edu.internet2.middleware.grouperClient.api.GcGetGroups;
88 import edu.internet2.middleware.grouperClient.api.GcGroupSave;
89 import edu.internet2.middleware.grouperClient.messaging.GrouperMessage;
90 import edu.internet2.middleware.grouperClient.messaging.GrouperMessageQueueType;
91 import edu.internet2.middleware.grouperClient.messaging.GrouperMessageReceiveParam;
92 import edu.internet2.middleware.grouperClient.messaging.GrouperMessageReceiveResult;
93 import edu.internet2.middleware.grouperClient.messaging.GrouperMessageSendParam;
94 import edu.internet2.middleware.grouperClient.messaging.GrouperMessagingEngine;
95 import edu.internet2.middleware.grouperClient.util.GrouperClientConfig;
96 import edu.internet2.middleware.grouperClient.util.GrouperClientUtils;
97 import edu.internet2.middleware.grouperClient.ws.GcWebServiceError;
98 import edu.internet2.middleware.grouperClient.ws.GrouperClientWs;
99 import edu.internet2.middleware.grouperClient.ws.beans.WsGetGroupsResults;
100 import edu.internet2.middleware.grouperClient.ws.beans.WsGroup;
101 import edu.internet2.middleware.grouperClient.ws.beans.WsGroupLookup;
102 import edu.internet2.middleware.grouperClient.ws.beans.WsGroupSaveResults;
103 import edu.internet2.middleware.grouperClient.ws.beans.WsGroupToSave;
104 import edu.internet2.middleware.grouperClient.ws.beans.WsMemberChangeSubjectResults;
105 import edu.internet2.middleware.subject.Subject;
106
107
108
109
110 public class GrouperClientWsTest extends GrouperTest {
111
112
113
114
115
116 public static void main(String[] args) {
117 TestRunner.run(new GrouperClientWsTest("testExternalSubjectSave"));
118
119
120 }
121
122
123
124
125
126 @Override
127 protected void setUp() {
128
129
130
131
132 String wsUserLabel = GrouperClientConfig.retrieveConfig().propertyValueStringRequired(
133 "grouperClient.webService.user.label");
134 String wsUserString = GrouperClientConfig.retrieveConfig().propertyValueStringRequired(
135 "grouperClient.webService." + wsUserLabel);
136
137 RestClientSettings.resetData(wsUserString, false);
138
139 GrouperConfig.retrieveConfig().propertiesOverrideMap().put("groups.create.grant.all.read", "true");
140 GrouperConfig.retrieveConfig().propertiesOverrideMap().put("groups.create.grant.all.view", "true");
141
142 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put("encrypt.key",
143 "sdfklj24lkj34lk34");
144 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
145 "encrypt.disableExternalFileLookup", "false");
146
147 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
148 .put(
149 "webService.addMember.output",
150 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsSubject.id}$newline$");
151 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
152 .put(
153 "webService.getMembers.output",
154 "GroupIndex ${groupIndex}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: group: ${wsGroup.name}: subjectIndex: ${subjectIndex}: ${wsSubject.id}$newline$");
155 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
156 .put(
157 "webService.deleteMember.output",
158 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsSubject.id}$newline$");
159 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
160 .put(
161 "webService.hasMember.output",
162 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsSubject.id}: ${hasMember}$newline$");
163 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
164 .put(
165 "webService.getGroups.output",
166 "SubjectIndex ${subjectIndex}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: subject: ${wsSubject.id}: groupIndex: ${groupIndex}: ${wsGroup.name}$newline$");
167 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
168 .put(
169 "webService.groupSave.output",
170 "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsGroup.name}$newline$");
171 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
172 .put(
173 "webService.stemSave.output",
174 "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsStem.name}$newline$");
175 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
176 .put(
177 "webService.groupDelete.output",
178 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsGroup.name}$newline$");
179 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
180 .put(
181 "webService.stemDelete.output",
182 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsStem.name}$newline$");
183 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
184 .put(
185 "webService.getGrouperPrivilegesLite.output",
186 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${objectType}: ${objectName}: subject: ${wsSubject.id}: ${wsGrouperPrivilegeResult.privilegeType}: ${wsGrouperPrivilegeResult.privilegeName}$newline$");
187 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
188 .put(
189 "webService.assignGrouperPrivilegesLite.output",
190 "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${objectType}: ${objectName}: subject: ${wsSubject.id}: ${wsAssignGrouperPrivilegesLiteResult.privilegeType}: ${wsAssignGrouperPrivilegesLiteResult.privilegeName}$newline$");
191 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
192 .put(
193 "webService.findGroups.output",
194 "Index ${index}: name: ${wsGroup.name}, displayName: ${wsGroup.displayName}$newline$");
195 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
196 .put(
197 "webService.findStems.output",
198 "Index ${index}: name: ${wsStem.name}, displayName: ${wsStem.displayName}$newline$");
199 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
200 .put(
201 "webService.memberChangeSubject.output",
202 "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: oldSubject: ${wsSubjectOld.id}, newSubject: ${wsSubjectNew.id}$newline$");
203
204 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
205 .put(
206 "webService.getSubjects.output",
207 "Index: ${index}: success: ${success}, code: ${wsSubject.resultCode}, subject: ${wsSubject.id}$newline$");
208
209 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
210 .put(
211 "webService.assignAttributeDefNameInheritance.output",
212 "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}, message: ${resultMetadata.resultMessage}$newline$");
213 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
214 .put(
215 "webService.attributeDefNameSave.output",
216 "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsAttributeDefName.name}$newline$");
217 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
218 .put(
219 "webService.attributeDefNameDelete.output",
220 "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsAttributeDefName.name}$newline$");
221 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
222 .put(
223 "webService.findAttributeDefNames.output",
224 "Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$");
225
226 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
227 "grouperClient.alias.subjectIds", "pennIds");
228 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
229 "grouperClient.alias.subjectIdentifiers", "pennKeys");
230 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
231 "grouperClient.alias.SubjectId", "PennId");
232 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
233 "grouperClient.alias.SubjectIdentifier", "PennKey");
234 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
235 "grouperClient.alias.subjectId", "pennId");
236 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
237 "grouperClient.alias.subjectIdentifier", "pennKey");
238
239 GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
240 .put(
241 "webService.hasMember.output",
242 "Index ${index}: success: ${wsHasMemberResult.resultMetadata.success}: code: ${wsHasMemberResult.resultMetadata.resultCode}: ${wsHasMemberResult.wsSubject.id}: ${hasMember}$newline$");
243
244
245 GrouperSession grouperSession = GrouperSession.startRootSession();
246
247 Group group = GroupFinder.findByName(grouperSession, "aStem:aGroup4", false);
248
249 if (group != null) {
250 group.delete();
251 }
252
253 GrouperClient.exitOnError = false;
254 }
255
256
257
258
259
260 @Override
261 protected void tearDown() {
262
263 GrouperClientConfig.retrieveConfig().propertiesOverrideMap().clear();
264
265 super.tearDown();
266
267 }
268
269
270
271
272 public GrouperClientWsTest(String name) {
273 super(name);
274 }
275
276
277
278
279 public void testAddMember() throws Exception {
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295 GrouperSession grouperSession = GrouperSession.startRootSession();
296 Group group = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
297
298 PrintStream systemOut = System.out;
299
300 ByteArrayOutputStream baos = new ByteArrayOutputStream();
301 System.setOut(new PrintStream(baos));
302
303 try {
304
305 GrouperClient
306 .main(GrouperClientUtils
307 .splitTrim(
308 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
309 " "));
310 System.out.flush();
311 String output = new String(baos.toByteArray());
312
313 System.setOut(systemOut);
314
315 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
316
317 Pattern pattern = Pattern
318 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
319 Matcher matcher = pattern.matcher(outputLines[0]);
320
321 assertTrue(outputLines[0], matcher.matches());
322
323 assertEquals(outputLines[0], "0", matcher.group(1));
324 assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
325 assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
326
327 matcher = pattern.matcher(outputLines[1]);
328
329 assertTrue(outputLines[1], matcher.matches());
330
331 assertEquals("1", matcher.group(1));
332 assertEquals("SUCCESS", matcher.group(2));
333 assertEquals("test.subject.1", matcher.group(3));
334
335
336
337 baos = new ByteArrayOutputStream();
338 System.setOut(new PrintStream(baos));
339
340 GrouperClient
341 .main(GrouperClientUtils
342 .splitTrim(
343 "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0,test.subject.1",
344 " "));
345 System.out.flush();
346 output = new String(baos.toByteArray());
347
348 System.setOut(systemOut);
349
350 outputLines = GrouperClientUtils.splitTrim(output, "\n");
351
352 matcher = pattern.matcher(outputLines[0]);
353
354 assertTrue(outputLines[0], matcher.matches());
355
356 assertEquals("0", matcher.group(1));
357 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
358 assertEquals("test.subject.0", matcher.group(3));
359
360 matcher = pattern.matcher(outputLines[1]);
361
362 assertTrue(outputLines[1], matcher.matches());
363
364 assertEquals("1", matcher.group(1));
365 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
366 assertEquals("test.subject.1", matcher.group(3));
367
368
369
370 baos = new ByteArrayOutputStream();
371 System.setOut(new PrintStream(baos));
372
373 GrouperClient
374 .main(GrouperClientUtils
375 .splitTrim(
376 "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0 --enabledTime=2010/02/03",
377 " "));
378 System.out.flush();
379 output = new String(baos.toByteArray());
380
381 System.setOut(systemOut);
382
383 outputLines = GrouperClientUtils.splitTrim(output, "\n");
384
385 matcher = pattern.matcher(outputLines[0]);
386
387 assertTrue(outputLines[0], matcher.matches());
388
389 assertEquals("0", matcher.group(1));
390 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
391 assertEquals("test.subject.0", matcher.group(3));
392
393 Membership membership = group.getImmediateMembership(Group.getDefaultList(), SubjectTestHelper.SUBJ0, false, true);
394 assertEquals(GrouperClientUtils.stringToDate("2010/02/03 00:00:00.000"), membership.getEnabledTime());
395 assertEquals(null, membership.getDisabledTime());
396
397
398
399 baos = new ByteArrayOutputStream();
400 System.setOut(new PrintStream(baos));
401
402 GrouperClient
403 .main(GrouperClientUtils
404 .splitTrim(
405 "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0 --disabledTime=2010/02/03",
406 " "));
407 System.out.flush();
408 output = new String(baos.toByteArray());
409
410 System.setOut(systemOut);
411
412 outputLines = GrouperClientUtils.splitTrim(output, "\n");
413
414 matcher = pattern.matcher(outputLines[0]);
415
416 assertTrue(outputLines[0], matcher.matches());
417
418 assertEquals("0", matcher.group(1));
419 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
420 assertEquals("test.subject.0", matcher.group(3));
421
422 membership = group.getImmediateMembership(Group.getDefaultList(), SubjectTestHelper.SUBJ0, false, true);
423 assertEquals(GrouperClientUtils.stringToDate("2010/02/03 00:00:00.000"), membership.getDisabledTime());
424 assertEquals(null, membership.getEnabledTime());
425
426
427
428 baos = new ByteArrayOutputStream();
429 System.setOut(new PrintStream(baos));
430
431 GrouperClient
432 .main(GrouperClientUtils
433 .splitTrim(
434 "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0",
435 " "));
436 System.out.flush();
437 output = new String(baos.toByteArray());
438
439 System.setOut(systemOut);
440
441 outputLines = GrouperClientUtils.splitTrim(output, "\n");
442
443 matcher = pattern.matcher(outputLines[0]);
444
445 assertTrue(outputLines[0], matcher.matches());
446
447 assertEquals("0", matcher.group(1));
448 assertEquals("SUCCESS", matcher.group(2));
449 assertEquals("test.subject.0", matcher.group(3));
450
451 membership = group.getImmediateMembership(Group.getDefaultList(), SubjectTestHelper.SUBJ0, false, true);
452 assertEquals(null, membership.getDisabledTime());
453 assertEquals(null, membership.getEnabledTime());
454
455
456
457 baos = new ByteArrayOutputStream();
458 System.setOut(new PrintStream(baos));
459
460 GrouperClient
461 .main(GrouperClientUtils
462 .splitTrim(
463 "--operation=addMemberWs --groupUuid=" + group.getUuid() + " --pennIds=test.subject.0,test.subject.1",
464 " "));
465 System.out.flush();
466 output = new String(baos.toByteArray());
467
468 System.setOut(systemOut);
469
470 outputLines = GrouperClientUtils.splitTrim(output, "\n");
471
472 matcher = pattern.matcher(outputLines[0]);
473
474 assertTrue(outputLines[0], matcher.matches());
475
476 assertEquals("0", matcher.group(1));
477 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
478 assertEquals("test.subject.0", matcher.group(3));
479
480 matcher = pattern.matcher(outputLines[1]);
481
482 assertTrue(outputLines[1], matcher.matches());
483
484 assertEquals("1", matcher.group(1));
485 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
486 assertEquals("test.subject.1", matcher.group(3));
487
488
489
490 baos = new ByteArrayOutputStream();
491 System.setOut(new PrintStream(baos));
492
493 GrouperClient
494 .main(GrouperClientUtils
495 .splitTrim(
496 "--operation=addMemberWs --groupIdIndex=" + group.getIdIndex() + " --pennIds=test.subject.0,test.subject.1",
497 " "));
498 System.out.flush();
499 output = new String(baos.toByteArray());
500
501 System.setOut(systemOut);
502
503 outputLines = GrouperClientUtils.splitTrim(output, "\n");
504
505 matcher = pattern.matcher(outputLines[0]);
506
507 assertTrue(outputLines[0], matcher.matches());
508
509 assertEquals("0", matcher.group(1));
510 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
511 assertEquals("test.subject.0", matcher.group(3));
512
513 matcher = pattern.matcher(outputLines[1]);
514
515 assertTrue(outputLines[1], matcher.matches());
516
517 assertEquals("1", matcher.group(1));
518 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
519 assertEquals("test.subject.1", matcher.group(3));
520
521
522
523 baos = new ByteArrayOutputStream();
524 System.setOut(new PrintStream(baos));
525
526
527 try {
528 GrouperClient
529 .main(GrouperClientUtils
530 .splitTrim(
531 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=${index}",
532 " "));
533 } catch (Exception e) {
534 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
535 }
536 System.out.flush();
537
538 System.setOut(systemOut);
539
540
541
542 baos = new ByteArrayOutputStream();
543 System.setOut(new PrintStream(baos));
544
545
546 GrouperClient
547 .main(GrouperClientUtils
548 .splitTrim(
549 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${index}",
550 " "));
551
552 System.out.flush();
553
554 output = new String(baos.toByteArray());
555
556 System.setOut(systemOut);
557
558 assertEquals("01", output);
559
560
561
562 baos = new ByteArrayOutputStream();
563 System.setOut(new PrintStream(baos));
564
565 GrouperClient
566 .main(GrouperClientUtils
567 .splitTrim(
568 "--operation=addMemberWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0,id.test.subject.1 --fieldName=members",
569 " "));
570 System.out.flush();
571 output = new String(baos.toByteArray());
572
573 System.setOut(systemOut);
574
575 outputLines = GrouperClientUtils.splitTrim(output, "\n");
576
577 matcher = pattern.matcher(outputLines[0]);
578
579 assertTrue(outputLines[0], matcher.matches());
580
581 assertEquals("0", matcher.group(1));
582 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
583 assertEquals("test.subject.0", matcher.group(3));
584
585 matcher = pattern.matcher(outputLines[1]);
586
587 assertTrue(outputLines[1], matcher.matches());
588
589 assertEquals("1", matcher.group(1));
590 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
591 assertEquals("test.subject.1", matcher.group(3));
592
593 assertTrue(GrouperClientWs.mostRecentRequest,
594 GrouperClientWs.mostRecentRequest.contains("fieldName")
595 && GrouperClientWs.mostRecentRequest.contains("members")
596 && !GrouperClientWs.mostRecentRequest.contains("txType"));
597
598
599
600 baos = new ByteArrayOutputStream();
601 System.setOut(new PrintStream(baos));
602
603 GrouperClient
604 .main(GrouperClientUtils
605 .splitTrim(
606 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --txType=NONE",
607 " "));
608 System.out.flush();
609 output = new String(baos.toByteArray());
610
611 System.setOut(systemOut);
612
613 outputLines = GrouperClientUtils.splitTrim(output, "\n");
614
615 matcher = pattern.matcher(outputLines[0]);
616
617 assertTrue(outputLines[0], matcher.matches());
618
619 assertEquals("0", matcher.group(1));
620 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
621 assertEquals("test.subject.0", matcher.group(3));
622
623 matcher = pattern.matcher(outputLines[1]);
624
625 assertTrue(outputLines[1], matcher.matches());
626
627 assertEquals("1", matcher.group(1));
628 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
629 assertEquals("test.subject.1", matcher.group(3));
630
631 assertTrue(GrouperClientWs.mostRecentRequest,
632 !GrouperClientWs.mostRecentRequest.contains("fieldName")
633 && !GrouperClientWs.mostRecentRequest.contains("members")
634 && GrouperClientWs.mostRecentRequest.contains("txType")
635 && GrouperClientWs.mostRecentRequest.contains("NONE")
636 && !GrouperClientWs.mostRecentRequest
637 .contains("includeGroupDetail")
638 && !GrouperClientWs.mostRecentRequest
639 .contains("includeSubjectDetail")
640 && !GrouperClientWs.mostRecentRequest
641 .contains("includeGroupDetail")
642 && !GrouperClientWs.mostRecentRequest
643 .contains("includeSubjectDetail"));
644
645
646
647 baos = new ByteArrayOutputStream();
648 System.setOut(new PrintStream(baos));
649
650 GrouperClient
651 .main(GrouperClientUtils
652 .splitTrim(
653 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
654 " "));
655 System.out.flush();
656 output = new String(baos.toByteArray());
657
658 System.setOut(systemOut);
659
660 outputLines = GrouperClientUtils.splitTrim(output, "\n");
661
662 matcher = pattern.matcher(outputLines[0]);
663
664 assertTrue(outputLines[0], matcher.matches());
665
666 assertEquals("0", matcher.group(1));
667 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
668 assertEquals("test.subject.0", matcher.group(3));
669
670 matcher = pattern.matcher(outputLines[1]);
671
672 assertTrue(outputLines[1], matcher.matches());
673
674 assertEquals("1", matcher.group(1));
675 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
676 assertEquals("test.subject.1", matcher.group(3));
677
678 assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
679 && !GrouperClientWs.mostRecentRequest.contains("NONE")
680 && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail")
681 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
682
683
684
685 baos = new ByteArrayOutputStream();
686 System.setOut(new PrintStream(baos));
687
688 GrouperClient
689 .main(GrouperClientUtils
690 .splitTrim(
691 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsAddMemberResult.wsSubject.getAttributeValue(0)}$newline$",
692 " "));
693 System.out.flush();
694 output = new String(baos.toByteArray());
695
696 System.setOut(systemOut);
697
698 outputLines = GrouperClientUtils.splitTrim(output, "\n");
699
700 assertTrue(outputLines[0], outputLines[0]
701 .contains("my name is test.subject.0"));
702
703 assertTrue(outputLines[1], outputLines[1]
704 .contains("my name is test.subject.1"));
705
706 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
707 assertTrue(GrouperClientWs.mostRecentResponse
708 .contains("my name is test.subject.0"));
709
710
711
712 baos = new ByteArrayOutputStream();
713 System.setOut(new PrintStream(baos));
714
715 GrouperClient
716 .main(GrouperClientUtils
717 .splitTrim(
718 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
719 " "));
720 System.out.flush();
721 output = new String(baos.toByteArray());
722
723 System.setOut(systemOut);
724
725 outputLines = GrouperClientUtils.splitTrim(output, "\n");
726
727 matcher = pattern.matcher(outputLines[0]);
728
729 assertTrue(outputLines[0], matcher.matches());
730
731 assertEquals("0", matcher.group(1));
732 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
733 assertEquals("test.subject.0", matcher.group(3));
734
735 matcher = pattern.matcher(outputLines[1]);
736
737 assertTrue(outputLines[1], matcher.matches());
738
739 assertEquals("1", matcher.group(1));
740 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
741 assertEquals("test.subject.1", matcher.group(3));
742
743 assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
744
745
746
747 baos = new ByteArrayOutputStream();
748 System.setOut(new PrintStream(baos));
749
750 String subjectIdsFileName = "subjectIdsFile_"
751 + GrouperClientUtils.uniqueId() + ".txt";
752 File subjectIdsFile = new File(subjectIdsFileName);
753
754 GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
755 "test.subject.0\ntest.subject.1");
756
757 try {
758 GrouperClient.main(GrouperClientUtils.splitTrim(
759 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIdsFile="
760 + subjectIdsFileName, " "));
761 System.out.flush();
762 output = new String(baos.toByteArray());
763
764 System.setOut(systemOut);
765
766 outputLines = GrouperClientUtils.splitTrim(output, "\n");
767
768 matcher = pattern.matcher(outputLines[0]);
769
770 assertTrue(outputLines[0], matcher.matches());
771
772 assertEquals("0", matcher.group(1));
773 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
774 assertEquals("test.subject.0", matcher.group(3));
775
776 matcher = pattern.matcher(outputLines[1]);
777
778 assertTrue(outputLines[1], matcher.matches());
779
780 assertEquals("1", matcher.group(1));
781 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
782 assertEquals("test.subject.1", matcher.group(3));
783
784
785
786 baos = new ByteArrayOutputStream();
787 System.setOut(new PrintStream(baos));
788
789 GrouperClient
790 .main(GrouperClientUtils
791 .splitTrim(
792 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --paramName0=whatever --paramValue0=someValue",
793 " "));
794 System.out.flush();
795 output = new String(baos.toByteArray());
796
797 System.setOut(systemOut);
798
799 outputLines = GrouperClientUtils.splitTrim(output, "\n");
800
801 matcher = pattern.matcher(outputLines[0]);
802
803 assertTrue(outputLines[0], matcher.matches());
804
805 assertEquals("0", matcher.group(1));
806 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
807 assertEquals("test.subject.0", matcher.group(3));
808
809 matcher = pattern.matcher(outputLines[1]);
810
811 assertTrue(outputLines[1], matcher.matches());
812
813 assertEquals("1", matcher.group(1));
814 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
815 assertEquals("test.subject.1", matcher.group(3));
816
817 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
818 && GrouperClientWs.mostRecentRequest.contains("someValue"));
819
820
821
822 baos = new ByteArrayOutputStream();
823 System.setOut(new PrintStream(baos));
824
825
826 GrouperClient
827 .main(GrouperClientUtils
828 .splitTrim(
829 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIdentifiers=a@b.c --addExternalSubjectIfNotFound=true",
830 " "));
831 System.out.flush();
832 output = new String(baos.toByteArray());
833
834 System.setOut(systemOut);
835
836 outputLines = GrouperClientUtils.splitTrim(output, "\n");
837 assertEquals(1, outputLines.length);
838
839 matcher = pattern.matcher(outputLines[0]);
840
841 assertTrue(outputLines[0], matcher.matches());
842
843 assertEquals("0", matcher.group(1));
844 assertEquals("SUCCESS_CREATED", matcher.group(2));
845
846
847
848 assertTrue(GrouperClientWs.mostRecentRequest
849 .contains("addExternalSubjectIfNotFound"));
850
851
852
853 baos = new ByteArrayOutputStream();
854 System.setOut(new PrintStream(baos));
855
856 GrouperClient
857 .main(GrouperClientUtils
858 .splitTrim(
859 "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --replaceAllExisting=true",
860 " "));
861 System.out.flush();
862 output = new String(baos.toByteArray());
863
864 System.setOut(systemOut);
865
866 outputLines = GrouperClientUtils.splitTrim(output, "\n");
867
868 matcher = pattern.matcher(outputLines[0]);
869
870 assertTrue(outputLines[0], matcher.matches());
871
872 assertEquals("0", matcher.group(1));
873 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
874 assertEquals("test.subject.0", matcher.group(3));
875
876 matcher = pattern.matcher(outputLines[1]);
877
878 assertTrue(outputLines[1], matcher.matches());
879
880 assertEquals("1", matcher.group(1));
881 assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
882 assertEquals("test.subject.1", matcher.group(3));
883
884 assertTrue(GrouperClientWs.mostRecentRequest
885 .contains("replaceAllExisting"));
886
887
888
889
890 baos = new ByteArrayOutputStream();
891 System.setOut(new PrintStream(baos));
892
893 GrouperClient
894 .main(GrouperClientUtils
895 .splitTrim(
896 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
897 " "));
898 System.out.flush();
899 output = new String(baos.toByteArray());
900
901 System.setOut(systemOut);
902
903 outputLines = GrouperClientUtils.splitTrim(output, "\n");
904
905 pattern = Pattern
906 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.+): (false|true)$");
907 matcher = pattern.matcher(outputLines[0]);
908
909 assertTrue(outputLines[0], matcher.matches());
910
911 assertEquals("0", matcher.group(1));
912 assertEquals("IS_MEMBER", matcher.group(2));
913 assertEquals("test.subject.0", matcher.group(3));
914 assertEquals("true", matcher.group(4));
915
916 matcher = pattern.matcher(outputLines[1]);
917
918 assertTrue(outputLines[1], matcher.matches());
919
920 assertEquals("1", matcher.group(1));
921 assertEquals("IS_MEMBER", matcher.group(2));
922 assertEquals("test.subject.1", matcher.group(3));
923 assertEquals("true", matcher.group(4));
924
925 } finally {
926 if (subjectIdsFile.exists()) {
927 subjectIdsFile.delete();
928 }
929 }
930 } finally {
931 System.setOut(systemOut);
932 }
933
934 }
935
936
937
938
939 public void testGetGrouperPrivilegeLite() throws Exception {
940
941 PrintStream systemOut = System.out;
942
943 ByteArrayOutputStream baos = new ByteArrayOutputStream();
944 System.setOut(new PrintStream(baos));
945
946 try {
947
948 GrouperClient
949 .main(GrouperClientUtils
950 .splitTrim(
951 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0",
952 " "));
953 System.out.flush();
954 String output = new String(baos.toByteArray());
955
956 System.setOut(systemOut);
957
958 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
959
960 Pattern pattern = Pattern
961 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (group|stem): (.+): subject: (.+): (.+): (.+)$");
962 Matcher matcher = pattern.matcher(outputLines[0]);
963
964 assertEquals(GrouperClientUtils.length(outputLines), 3);
965 assertTrue(outputLines[0], matcher.matches());
966
967 assertEquals("0", matcher.group(1));
968 assertEquals("SUCCESS", matcher.group(2));
969 assertEquals("group", matcher.group(3));
970 assertEquals("aStem:aGroup", matcher.group(4));
971 assertEquals("test.subject.0", matcher.group(5));
972 assertEquals("access", matcher.group(6));
973 assertEquals("admin", matcher.group(7));
974
975 matcher = pattern.matcher(outputLines[1]);
976
977 assertTrue(outputLines[1], matcher.matches());
978
979 assertEquals("1", matcher.group(1));
980 assertEquals("SUCCESS", matcher.group(2));
981 assertEquals("group", matcher.group(3));
982 assertEquals("aStem:aGroup", matcher.group(4));
983 assertEquals("test.subject.0", matcher.group(5));
984 assertEquals("access", matcher.group(6));
985 assertEquals("read", matcher.group(7));
986
987 matcher = pattern.matcher(outputLines[2]);
988
989 assertTrue(outputLines[2], matcher.matches());
990
991 assertEquals("2", matcher.group(1));
992 assertEquals("SUCCESS", matcher.group(2));
993 assertEquals("group", matcher.group(3));
994 assertEquals("aStem:aGroup", matcher.group(4));
995 assertEquals("test.subject.0", matcher.group(5));
996 assertEquals("access", matcher.group(6));
997 assertEquals("view", matcher.group(7));
998
999
1000
1001 baos = new ByteArrayOutputStream();
1002 System.setOut(new PrintStream(baos));
1003
1004 GrouperClient
1005 .main(GrouperClientUtils
1006 .splitTrim(
1007 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectIdentifier=id.test.subject.0 --privilegeType=access",
1008 " "));
1009 System.out.flush();
1010 output = new String(baos.toByteArray());
1011
1012 System.setOut(systemOut);
1013
1014 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1015
1016 matcher = pattern.matcher(outputLines[0]);
1017
1018 assertEquals(GrouperClientUtils.length(outputLines), 3);
1019 assertTrue(outputLines[0], matcher.matches());
1020
1021 assertEquals("0", matcher.group(1));
1022 assertEquals("SUCCESS", matcher.group(2));
1023 assertEquals("group", matcher.group(3));
1024 assertEquals("aStem:aGroup", matcher.group(4));
1025 assertEquals("test.subject.0", matcher.group(5));
1026 assertEquals("access", matcher.group(6));
1027 assertEquals("admin", matcher.group(7));
1028
1029 matcher = pattern.matcher(outputLines[1]);
1030
1031 assertTrue(outputLines[1], matcher.matches());
1032
1033 assertEquals("1", matcher.group(1));
1034 assertEquals("SUCCESS", matcher.group(2));
1035 assertEquals("group", matcher.group(3));
1036 assertEquals("aStem:aGroup", matcher.group(4));
1037 assertEquals("test.subject.0", matcher.group(5));
1038 assertEquals("access", matcher.group(6));
1039 assertEquals("read", matcher.group(7));
1040
1041 matcher = pattern.matcher(outputLines[2]);
1042
1043 assertTrue(outputLines[2], matcher.matches());
1044
1045 assertEquals("2", matcher.group(1));
1046 assertEquals("SUCCESS", matcher.group(2));
1047 assertEquals("group", matcher.group(3));
1048 assertEquals("aStem:aGroup", matcher.group(4));
1049 assertEquals("test.subject.0", matcher.group(5));
1050 assertEquals("access", matcher.group(6));
1051 assertEquals("view", matcher.group(7));
1052
1053 assertTrue(GrouperClientWs.mostRecentRequest,
1054 GrouperClientWs.mostRecentRequest.contains("access")
1055 && GrouperClientWs.mostRecentRequest.contains("privilegeType")
1056 && GrouperClientWs.mostRecentRequest
1057 .contains("id.test.subject.0"));
1058
1059
1060
1061 baos = new ByteArrayOutputStream();
1062 System.setOut(new PrintStream(baos));
1063
1064
1065 try {
1066 GrouperClient
1067 .main(GrouperClientUtils
1068 .splitTrim(
1069 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --ousdfsdfate=${index}",
1070 " "));
1071 } catch (Exception e) {
1072 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1073 }
1074 System.out.flush();
1075
1076 System.setOut(systemOut);
1077
1078
1079
1080 baos = new ByteArrayOutputStream();
1081 System.setOut(new PrintStream(baos));
1082
1083
1084 GrouperClient
1085 .main(GrouperClientUtils
1086 .splitTrim(
1087 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --pennKey=id.test.subject.0 --outputTemplate=${index}",
1088 " "));
1089
1090 System.out.flush();
1091
1092 output = new String(baos.toByteArray());
1093
1094 assertEquals("012", output);
1095
1096 System.setOut(systemOut);
1097
1098
1099
1100 baos = new ByteArrayOutputStream();
1101 System.setOut(new PrintStream(baos));
1102
1103
1104 GrouperClient
1105 .main(GrouperClientUtils
1106 .splitTrim(
1107 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --pennKey=id.test.subject.0 --privilegeName=admin",
1108 " "));
1109
1110 System.out.flush();
1111
1112 output = new String(baos.toByteArray());
1113
1114 System.setOut(systemOut);
1115
1116 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1117
1118 matcher = pattern.matcher(outputLines[0]);
1119
1120 assertEquals(output, GrouperClientUtils.length(outputLines), 1);
1121 assertTrue(outputLines[0], matcher.matches());
1122
1123 assertEquals("0", matcher.group(1));
1124 assertEquals(outputLines[0], "SUCCESS_ALLOWED", matcher.group(2));
1125 assertEquals("group", matcher.group(3));
1126 assertEquals("aStem:aGroup", matcher.group(4));
1127 assertEquals("test.subject.0", matcher.group(5));
1128 assertEquals("access", matcher.group(6));
1129 assertEquals("admin", matcher.group(7));
1130
1131 assertTrue(GrouperClientWs.mostRecentRequest,
1132 GrouperClientWs.mostRecentRequest.contains("admin")
1133 && GrouperClientWs.mostRecentRequest.contains("privilegeName")
1134 && GrouperClientWs.mostRecentRequest
1135 .contains("id.test.subject.0"));
1136
1137
1138
1139 baos = new ByteArrayOutputStream();
1140 System.setOut(new PrintStream(baos));
1141
1142 GrouperClient
1143 .main(GrouperClientUtils
1144 .splitTrim(
1145 "--operation=getGrouperPrivilegesLiteWs --stemName=aStem --pennKey=id.test.subject.0",
1146 " "));
1147 System.out.flush();
1148 output = new String(baos.toByteArray());
1149
1150 System.setOut(systemOut);
1151
1152 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1153
1154 matcher = pattern.matcher(outputLines[0]);
1155
1156 assertEquals(GrouperClientUtils.length(outputLines), 2);
1157 assertTrue(outputLines[0], matcher.matches());
1158
1159
1160
1161 baos = new ByteArrayOutputStream();
1162 System.setOut(new PrintStream(baos));
1163
1164 GrouperClient
1165 .main(GrouperClientUtils
1166 .splitTrim(
1167 "--operation=getGrouperPrivilegesLiteWs --stemName=aStem --pennKey=id.test.subject.6",
1168 " "));
1169 System.out.flush();
1170 output = new String(baos.toByteArray());
1171
1172 System.setOut(systemOut);
1173
1174 assertTrue(outputLines[0], StringUtils.isBlank(output));
1175
1176
1177
1178
1179
1180
1181 assertEquals("0", matcher.group(1));
1182 assertEquals("SUCCESS", matcher.group(2));
1183 assertEquals("stem", matcher.group(3));
1184 assertEquals("aStem", matcher.group(4));
1185 assertEquals("test.subject.0", matcher.group(5));
1186 assertEquals("naming", matcher.group(6));
1187 assertEquals("create", matcher.group(7));
1188
1189 matcher = pattern.matcher(outputLines[1]);
1190
1191 assertTrue(outputLines[1], matcher.matches());
1192
1193 assertEquals("1", matcher.group(1));
1194 assertEquals("SUCCESS", matcher.group(2));
1195 assertEquals("stem", matcher.group(3));
1196 assertEquals("aStem", matcher.group(4));
1197 assertEquals("test.subject.0", matcher.group(5));
1198 assertEquals("naming", matcher.group(6));
1199 assertEquals("stemAdmin", matcher.group(7));
1200
1201
1202
1203 baos = new ByteArrayOutputStream();
1204 System.setOut(new PrintStream(baos));
1205
1206 GrouperClient
1207 .main(GrouperClientUtils
1208 .splitTrim(
1209 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --includeGroupDetail=true --includeSubjectDetail=true",
1210 " "));
1211 System.out.flush();
1212 output = new String(baos.toByteArray());
1213
1214 System.setOut(systemOut);
1215
1216 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1217
1218 matcher = pattern.matcher(outputLines[0]);
1219
1220 assertEquals(3, GrouperClientUtils.length(outputLines));
1221 assertTrue(outputLines[0], matcher.matches());
1222
1223 assertEquals("0", matcher.group(1));
1224 assertEquals("SUCCESS", matcher.group(2));
1225 assertEquals("group", matcher.group(3));
1226 assertEquals("aStem:aGroup", matcher.group(4));
1227 assertEquals("test.subject.0", matcher.group(5));
1228 assertEquals("access", matcher.group(6));
1229 assertEquals("admin", matcher.group(7));
1230
1231 matcher = pattern.matcher(outputLines[1]);
1232
1233 assertTrue(outputLines[1], matcher.matches());
1234
1235 assertEquals("1", matcher.group(1));
1236 assertEquals("SUCCESS", matcher.group(2));
1237 assertEquals("group", matcher.group(3));
1238 assertEquals("aStem:aGroup", matcher.group(4));
1239 assertEquals("test.subject.0", matcher.group(5));
1240 assertEquals("access", matcher.group(6));
1241 assertEquals("read", matcher.group(7));
1242
1243 matcher = pattern.matcher(outputLines[2]);
1244
1245 assertTrue(outputLines[2], matcher.matches());
1246
1247 assertEquals("2", matcher.group(1));
1248 assertEquals("SUCCESS", matcher.group(2));
1249 assertEquals("group", matcher.group(3));
1250 assertEquals("aStem:aGroup", matcher.group(4));
1251 assertEquals("test.subject.0", matcher.group(5));
1252 assertEquals("access", matcher.group(6));
1253 assertEquals("view", matcher.group(7));
1254
1255 assertTrue(GrouperClientWs.mostRecentRequest
1256 .contains("includeGroupDetail")
1257 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
1258
1259
1260
1261 baos = new ByteArrayOutputStream();
1262 System.setOut(new PrintStream(baos));
1263
1264 GrouperClient
1265 .main(GrouperClientUtils
1266 .splitTrim(
1267 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsSubject.getAttributeValue(0)}$newline$",
1268 " "));
1269 System.out.flush();
1270 output = new String(baos.toByteArray());
1271
1272 System.setOut(systemOut);
1273
1274 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1275
1276 assertTrue(outputLines[0], outputLines[0]
1277 .contains("my name is test.subject.0"));
1278
1279 assertTrue(outputLines[1], outputLines[1]
1280 .contains("my name is test.subject.0"));
1281
1282 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
1283 assertTrue(GrouperClientWs.mostRecentResponse
1284 .contains("my name is test.subject.0"));
1285
1286
1287
1288 baos = new ByteArrayOutputStream();
1289 System.setOut(new PrintStream(baos));
1290
1291 GrouperClient
1292 .main(GrouperClientUtils
1293 .splitTrim(
1294 "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --paramName0=whatever --paramValue0=someValue",
1295 " "));
1296 System.out.flush();
1297 output = new String(baos.toByteArray());
1298
1299 System.setOut(systemOut);
1300
1301 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1302
1303 matcher = pattern.matcher(outputLines[0]);
1304
1305 assertEquals(GrouperClientUtils.length(outputLines), 3);
1306 assertTrue(outputLines[0], matcher.matches());
1307
1308 assertEquals("0", matcher.group(1));
1309 assertEquals("SUCCESS", matcher.group(2));
1310 assertEquals("group", matcher.group(3));
1311 assertEquals("aStem:aGroup", matcher.group(4));
1312 assertEquals("test.subject.0", matcher.group(5));
1313 assertEquals("access", matcher.group(6));
1314 assertEquals("admin", matcher.group(7));
1315
1316 matcher = pattern.matcher(outputLines[1]);
1317
1318 assertTrue(outputLines[1], matcher.matches());
1319
1320 assertEquals("1", matcher.group(1));
1321 assertEquals("SUCCESS", matcher.group(2));
1322 assertEquals("group", matcher.group(3));
1323 assertEquals("aStem:aGroup", matcher.group(4));
1324 assertEquals("test.subject.0", matcher.group(5));
1325 assertEquals("access", matcher.group(6));
1326 assertEquals("read", matcher.group(7));
1327
1328 matcher = pattern.matcher(outputLines[2]);
1329
1330 assertTrue(outputLines[2], matcher.matches());
1331
1332 assertEquals("2", matcher.group(1));
1333 assertEquals("SUCCESS", matcher.group(2));
1334 assertEquals("group", matcher.group(3));
1335 assertEquals("aStem:aGroup", matcher.group(4));
1336 assertEquals("test.subject.0", matcher.group(5));
1337 assertEquals("access", matcher.group(6));
1338 assertEquals("view", matcher.group(7));
1339
1340 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1341 && GrouperClientWs.mostRecentRequest.contains("someValue"));
1342
1343 } finally {
1344 System.setOut(systemOut);
1345 }
1346
1347 }
1348
1349
1350
1351
1352 public void testAssignGrouperPrivilegeLite() throws Exception {
1353
1354 PrintStream systemOut = System.out;
1355
1356 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1357 System.setOut(new PrintStream(baos));
1358
1359 try {
1360
1361 GrouperClient
1362 .main(GrouperClientUtils
1363 .splitTrim(
1364 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --privilegeName=optin --allowed=true",
1365 " "));
1366 System.out.flush();
1367 String output = new String(baos.toByteArray());
1368
1369 System.setOut(systemOut);
1370
1371 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
1372
1373 Pattern pattern = Pattern
1374 .compile("^Success: T: code: ([A-Z_]+): (group|stem): (.+): subject: (.+): (.+): (.+)$");
1375 Matcher matcher = pattern.matcher(outputLines[0]);
1376
1377 assertEquals(GrouperClientUtils.length(outputLines), 1);
1378 assertTrue(outputLines[0], matcher.matches());
1379
1380 assertEquals("SUCCESS_ALLOWED", matcher.group(1));
1381 assertEquals("group", matcher.group(2));
1382 assertEquals("aStem:aGroup", matcher.group(3));
1383 assertEquals("test.subject.0", matcher.group(4));
1384 assertEquals("access", matcher.group(5));
1385 assertEquals("optin", matcher.group(6));
1386
1387
1388
1389 baos = new ByteArrayOutputStream();
1390 System.setOut(new PrintStream(baos));
1391
1392 GrouperClient
1393 .main(GrouperClientUtils
1394 .splitTrim(
1395 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectIdentifier=id.test.subject.0 --privilegeType=access --privilegeName=optin --allowed=true",
1396 " "));
1397 System.out.flush();
1398 output = new String(baos.toByteArray());
1399
1400 System.setOut(systemOut);
1401
1402 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1403
1404 matcher = pattern.matcher(outputLines[0]);
1405
1406 assertEquals(GrouperClientUtils.length(outputLines), 1);
1407 assertTrue(outputLines[0], matcher.matches());
1408
1409 assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(1));
1410 assertEquals("group", matcher.group(2));
1411 assertEquals("aStem:aGroup", matcher.group(3));
1412 assertEquals("test.subject.0", matcher.group(4));
1413 assertEquals("access", matcher.group(5));
1414 assertEquals("optin", matcher.group(6));
1415
1416 assertTrue(GrouperClientWs.mostRecentRequest,
1417 GrouperClientWs.mostRecentRequest.contains("access")
1418 && GrouperClientWs.mostRecentRequest.contains("privilegeType")
1419 && GrouperClientWs.mostRecentRequest
1420 .contains("id.test.subject.0"));
1421
1422
1423
1424 baos = new ByteArrayOutputStream();
1425 System.setOut(new PrintStream(baos));
1426
1427
1428 try {
1429 GrouperClient
1430 .main(GrouperClientUtils
1431 .splitTrim(
1432 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --privilegeName=optin --allowed=true --ousdfsdfate=${index}",
1433 " "));
1434 } catch (Exception e) {
1435 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1436 }
1437 System.out.flush();
1438
1439 System.setOut(systemOut);
1440
1441
1442
1443 baos = new ByteArrayOutputStream();
1444 System.setOut(new PrintStream(baos));
1445
1446
1447 GrouperClient
1448 .main(GrouperClientUtils
1449 .splitTrim(
1450 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --pennKey=id.test.subject.0 --privilegeName=optin --allowed=true --outputTemplate=${wsSubject.identifierLookup}",
1451 " "));
1452
1453 System.out.flush();
1454
1455 output = new String(baos.toByteArray());
1456
1457 assertEquals("id.test.subject.0", output);
1458
1459 System.setOut(systemOut);
1460
1461
1462
1463 baos = new ByteArrayOutputStream();
1464 System.setOut(new PrintStream(baos));
1465
1466 GrouperClient
1467 .main(GrouperClientUtils
1468 .splitTrim(
1469 "--operation=assignGrouperPrivilegesLiteWs --stemName=aStem --pennKey=id.test.subject.0 --privilegeName=stem --allowed=true",
1470 " "));
1471 System.out.flush();
1472 output = new String(baos.toByteArray());
1473
1474 System.setOut(systemOut);
1475
1476 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1477
1478 matcher = pattern.matcher(outputLines[0]);
1479
1480 assertEquals(GrouperClientUtils.length(outputLines), 1);
1481 assertTrue(outputLines[0], matcher.matches());
1482
1483 assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(1));
1484 assertEquals("stem", matcher.group(2));
1485 assertEquals("aStem", matcher.group(3));
1486 assertEquals("test.subject.0", matcher.group(4));
1487 assertEquals("naming", matcher.group(5));
1488 assertEquals("stemAdmin", matcher.group(6));
1489
1490
1491
1492 baos = new ByteArrayOutputStream();
1493 System.setOut(new PrintStream(baos));
1494
1495 GrouperClient
1496 .main(GrouperClientUtils
1497 .splitTrim(
1498 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --includeGroupDetail=true --includeSubjectDetail=true --privilegeName=optin --allowed=false",
1499 " "));
1500 System.out.flush();
1501 output = new String(baos.toByteArray());
1502
1503 System.setOut(systemOut);
1504
1505 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1506
1507 matcher = pattern.matcher(outputLines[0]);
1508
1509 assertEquals(GrouperClientUtils.length(outputLines), 1);
1510 assertTrue(outputLines[0], matcher.matches());
1511
1512 assertEquals("SUCCESS_NOT_ALLOWED", matcher.group(1));
1513 assertEquals("group", matcher.group(2));
1514 assertEquals("aStem:aGroup", matcher.group(3));
1515 assertEquals("test.subject.0", matcher.group(4));
1516 assertEquals("access", matcher.group(5));
1517 assertEquals("optin", matcher.group(6));
1518
1519 assertTrue(GrouperClientWs.mostRecentRequest
1520 .contains("includeGroupDetail")
1521 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
1522
1523
1524
1525 baos = new ByteArrayOutputStream();
1526 System.setOut(new PrintStream(baos));
1527
1528 GrouperClient
1529 .main(GrouperClientUtils
1530 .splitTrim(
1531 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --subjectAttributeNames=name --privilegeName=optin --allowed=false --outputTemplate=${index}:$space$${wsSubject.getAttributeValue(0)}$newline$",
1532 " "));
1533 System.out.flush();
1534 output = new String(baos.toByteArray());
1535
1536 System.setOut(systemOut);
1537
1538 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1539
1540 assertTrue(outputLines[0], outputLines[0]
1541 .contains("my name is test.subject.0"));
1542
1543 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
1544 assertTrue(GrouperClientWs.mostRecentResponse
1545 .contains("my name is test.subject.0"));
1546
1547
1548
1549 baos = new ByteArrayOutputStream();
1550 System.setOut(new PrintStream(baos));
1551
1552 GrouperClient
1553 .main(GrouperClientUtils
1554 .splitTrim(
1555 "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --privilegeName=optin --allowed=false --subjectId=test.subject.0 --paramName0=whatever --paramValue0=someValue",
1556 " "));
1557 System.out.flush();
1558 output = new String(baos.toByteArray());
1559
1560 System.setOut(systemOut);
1561
1562 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1563
1564 matcher = pattern.matcher(outputLines[0]);
1565
1566 assertEquals(GrouperClientUtils.length(outputLines), 1);
1567 assertTrue(outputLines[0], matcher.matches());
1568
1569 assertEquals("SUCCESS_NOT_ALLOWED_DIDNT_EXIST", matcher.group(1));
1570 assertEquals("group", matcher.group(2));
1571 assertEquals("aStem:aGroup", matcher.group(3));
1572 assertEquals("test.subject.0", matcher.group(4));
1573 assertEquals("access", matcher.group(5));
1574 assertEquals("optin", matcher.group(6));
1575
1576 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1577 && GrouperClientWs.mostRecentRequest.contains("someValue"));
1578
1579 } finally {
1580 System.setOut(systemOut);
1581 }
1582
1583 }
1584
1585
1586
1587
1588 public void testGroupDelete() throws Exception {
1589
1590 PrintStream systemOut = System.out;
1591
1592 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1593 System.setOut(new PrintStream(baos));
1594
1595 try {
1596
1597 GrouperClient.main(GrouperClientUtils.splitTrim(
1598 "--operation=groupDeleteWs --groupNames=aStem:aGroup", " "));
1599 System.out.flush();
1600 String output = new String(baos.toByteArray());
1601
1602 System.setOut(systemOut);
1603
1604 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
1605
1606 Pattern pattern = Pattern
1607 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
1608 Matcher matcher = pattern.matcher(outputLines[0]);
1609
1610 assertTrue(outputLines[0], matcher.matches());
1611
1612 assertEquals("0", matcher.group(1));
1613 assertEquals("SUCCESS", matcher.group(2));
1614 assertEquals("aStem:aGroup", matcher.group(3));
1615
1616
1617
1618 baos = new ByteArrayOutputStream();
1619 System.setOut(new PrintStream(baos));
1620
1621 GrouperClient.main(GrouperClientUtils.splitTrim(
1622 "--operation=groupDeleteWs --groupNames=aStem:aGroup", " "));
1623 System.out.flush();
1624 output = new String(baos.toByteArray());
1625
1626 System.setOut(systemOut);
1627
1628 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1629
1630 matcher = pattern.matcher(outputLines[0]);
1631
1632 assertTrue(outputLines[0], matcher.matches());
1633
1634 assertEquals("0", matcher.group(1));
1635 assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1636 assertEquals("aStem:aGroup", matcher.group(3));
1637
1638
1639
1640 baos = new ByteArrayOutputStream();
1641 System.setOut(new PrintStream(baos));
1642
1643
1644 try {
1645 GrouperClient
1646 .main(GrouperClientUtils
1647 .splitTrim(
1648 "--operation=groupDeleteWs --groupNames=aStem:aGroup --ousdfsdfate=${index}",
1649 " "));
1650 } catch (Exception e) {
1651 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1652 }
1653 System.out.flush();
1654
1655 System.setOut(systemOut);
1656
1657
1658
1659 baos = new ByteArrayOutputStream();
1660 System.setOut(new PrintStream(baos));
1661
1662
1663 GrouperClient
1664 .main(GrouperClientUtils
1665 .splitTrim(
1666 "--operation=groupDeleteWs --groupNames=aStem:aGroup --outputTemplate=${index}",
1667 " "));
1668
1669 System.out.flush();
1670
1671 output = new String(baos.toByteArray());
1672
1673 System.setOut(systemOut);
1674
1675 assertEquals("0", output);
1676
1677
1678
1679 baos = new ByteArrayOutputStream();
1680 System.setOut(new PrintStream(baos));
1681
1682 GrouperClient.main(GrouperClientUtils.splitTrim(
1683 "--operation=groupDeleteWs --groupNames=aStem:aGroup --txType=NONE",
1684 " "));
1685 System.out.flush();
1686 output = new String(baos.toByteArray());
1687
1688 System.setOut(systemOut);
1689
1690 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1691
1692 matcher = pattern.matcher(outputLines[0]);
1693
1694 assertTrue(outputLines[0], matcher.matches());
1695
1696 assertEquals("0", matcher.group(1));
1697 assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1698 assertEquals("aStem:aGroup", matcher.group(3));
1699
1700 assertTrue(GrouperClientWs.mostRecentRequest,
1701 GrouperClientWs.mostRecentRequest.contains("txType")
1702 && GrouperClientWs.mostRecentRequest.contains("NONE"));
1703
1704
1705
1706 baos = new ByteArrayOutputStream();
1707 System.setOut(new PrintStream(baos));
1708
1709 GrouperClient
1710 .main(GrouperClientUtils
1711 .splitTrim(
1712 "--operation=groupDeleteWs --groupNames=aStem:aGroup --includeGroupDetail=true",
1713 " "));
1714 System.out.flush();
1715 output = new String(baos.toByteArray());
1716
1717 System.setOut(systemOut);
1718
1719 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1720
1721 matcher = pattern.matcher(outputLines[0]);
1722
1723 assertTrue(outputLines[0], matcher.matches());
1724
1725 assertEquals("0", matcher.group(1));
1726 assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1727 assertEquals("aStem:aGroup", matcher.group(3));
1728
1729 assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
1730 && !GrouperClientWs.mostRecentRequest.contains("NONE")
1731 && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
1732
1733
1734
1735 baos = new ByteArrayOutputStream();
1736 System.setOut(new PrintStream(baos));
1737
1738 GrouperClient
1739 .main(GrouperClientUtils
1740 .splitTrim(
1741 "--operation=groupDeleteWs --groupNames=aStem:aGroup --paramName0=whatever --paramValue0=someValue",
1742 " "));
1743 System.out.flush();
1744 output = new String(baos.toByteArray());
1745
1746 System.setOut(systemOut);
1747
1748 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1749
1750 matcher = pattern.matcher(outputLines[0]);
1751
1752 assertTrue(outputLines[0], matcher.matches());
1753
1754 assertEquals("0", matcher.group(1));
1755 assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1756 assertEquals("aStem:aGroup", matcher.group(3));
1757
1758 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1759 && GrouperClientWs.mostRecentRequest.contains("someValue"));
1760
1761 } finally {
1762 System.setOut(systemOut);
1763 }
1764
1765 }
1766
1767
1768
1769
1770 public void testStemDelete() throws Exception {
1771
1772 PrintStream systemOut = System.out;
1773
1774 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1775 System.setOut(new PrintStream(baos));
1776
1777 try {
1778
1779 GrouperClient.main(GrouperClientUtils.splitTrim(
1780 "--operation=stemDeleteWs --stemNames=aStem:aStem0", " "));
1781 System.out.flush();
1782 String output = new String(baos.toByteArray());
1783
1784 System.setOut(systemOut);
1785
1786 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
1787
1788 Pattern pattern = Pattern
1789 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
1790 Matcher matcher = pattern.matcher(outputLines[0]);
1791
1792 assertTrue(outputLines[0], matcher.matches());
1793
1794 assertEquals("0", matcher.group(1));
1795 assertEquals("SUCCESS", matcher.group(2));
1796 assertEquals("aStem:aStem0", matcher.group(3));
1797
1798
1799
1800 baos = new ByteArrayOutputStream();
1801 System.setOut(new PrintStream(baos));
1802
1803 GrouperClient.main(GrouperClientUtils.splitTrim(
1804 "--operation=stemDeleteWs --stemNames=aStem:aStem0", " "));
1805 System.out.flush();
1806 output = new String(baos.toByteArray());
1807
1808 System.setOut(systemOut);
1809
1810 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1811
1812 matcher = pattern.matcher(outputLines[0]);
1813
1814 assertTrue(outputLines[0], matcher.matches());
1815
1816 assertEquals("0", matcher.group(1));
1817 assertEquals("SUCCESS_STEM_NOT_FOUND", matcher.group(2));
1818 assertEquals("aStem:aStem0", matcher.group(3));
1819
1820
1821
1822 baos = new ByteArrayOutputStream();
1823 System.setOut(new PrintStream(baos));
1824
1825
1826 try {
1827 GrouperClient
1828 .main(GrouperClientUtils
1829 .splitTrim(
1830 "--operation=stemDeleteWs --stemNames=aStem:aStem0 --ousdfsdfate=${index}",
1831 " "));
1832 } catch (Exception e) {
1833 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1834 }
1835 System.out.flush();
1836
1837 System.setOut(systemOut);
1838
1839
1840
1841 baos = new ByteArrayOutputStream();
1842 System.setOut(new PrintStream(baos));
1843
1844
1845 GrouperClient
1846 .main(GrouperClientUtils
1847 .splitTrim(
1848 "--operation=stemDeleteWs --stemNames=aStem:aStem0 --outputTemplate=${index}",
1849 " "));
1850
1851 System.out.flush();
1852
1853 output = new String(baos.toByteArray());
1854
1855 System.setOut(systemOut);
1856
1857 assertEquals("0", output);
1858
1859
1860
1861 baos = new ByteArrayOutputStream();
1862 System.setOut(new PrintStream(baos));
1863
1864 GrouperClient.main(GrouperClientUtils.splitTrim(
1865 "--operation=stemDeleteWs --stemNames=aStem:aStem0 --txType=NONE",
1866 " "));
1867 System.out.flush();
1868 output = new String(baos.toByteArray());
1869
1870 System.setOut(systemOut);
1871
1872 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1873
1874 matcher = pattern.matcher(outputLines[0]);
1875
1876 assertTrue(outputLines[0], matcher.matches());
1877
1878 assertEquals("0", matcher.group(1));
1879 assertEquals("SUCCESS_STEM_NOT_FOUND", matcher.group(2));
1880 assertEquals("aStem:aStem0", matcher.group(3));
1881
1882 assertTrue(GrouperClientWs.mostRecentRequest,
1883 GrouperClientWs.mostRecentRequest.contains("txType")
1884 && GrouperClientWs.mostRecentRequest.contains("NONE"));
1885
1886
1887
1888 baos = new ByteArrayOutputStream();
1889 System.setOut(new PrintStream(baos));
1890
1891 GrouperClient
1892 .main(GrouperClientUtils
1893 .splitTrim(
1894 "--operation=stemDeleteWs --stemNames=aStem:aStem0 --paramName0=whatever --paramValue0=someValue",
1895 " "));
1896 System.out.flush();
1897 output = new String(baos.toByteArray());
1898
1899 System.setOut(systemOut);
1900
1901 outputLines = GrouperClientUtils.splitTrim(output, "\n");
1902
1903 matcher = pattern.matcher(outputLines[0]);
1904
1905 assertTrue(outputLines[0], matcher.matches());
1906
1907 assertEquals("0", matcher.group(1));
1908 assertEquals("SUCCESS_STEM_NOT_FOUND", matcher.group(2));
1909 assertEquals("aStem:aStem0", matcher.group(3));
1910
1911 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1912 && GrouperClientWs.mostRecentRequest.contains("someValue"));
1913
1914 } finally {
1915 System.setOut(systemOut);
1916 }
1917
1918 }
1919
1920
1921
1922
1923
1924 public void testGroupSaveNoLookup() throws Exception {
1925
1926 WsGroupToSave wsGroupToSave = new WsGroupToSave();
1927 wsGroupToSave.setSaveMode("INSERT");
1928
1929 WsGroup wsGroup = new WsGroup();
1930 wsGroup.setDisplayExtension("a group4");
1931 wsGroup.setExtension("aGroup4");
1932 wsGroup.setName("aStem:aGroup4");
1933 wsGroupToSave.setWsGroup(wsGroup);
1934 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1935
1936
1937 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
1938
1939 assertEquals("SUCCESS_INSERTED", resultCode);
1940 }
1941
1942
1943
1944
1945
1946 public void testGroupSaveLookupNameSame() throws Exception {
1947
1948 WsGroupToSave wsGroupToSave = new WsGroupToSave();
1949 wsGroupToSave.setSaveMode("INSERT");
1950 wsGroupToSave.setWsGroupLookup(new WsGroupLookup("aStem:aGroup4", null));
1951 WsGroup wsGroup = new WsGroup();
1952 wsGroup.setDisplayExtension("a group4");
1953 wsGroup.setExtension("aGroup4");
1954 wsGroup.setName("aStem:aGroup4");
1955 wsGroupToSave.setWsGroup(wsGroup);
1956 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1957
1958
1959 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
1960
1961 assertEquals("SUCCESS_INSERTED", resultCode);
1962 }
1963
1964
1965
1966
1967
1968 public void testGroupSaveInsertAlreadyExists() throws Exception {
1969
1970 {
1971 WsGroupToSave wsGroupToSave = new WsGroupToSave();
1972 wsGroupToSave.setSaveMode("INSERT");
1973 wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
1974 WsGroup wsGroup = new WsGroup();
1975 wsGroup.setDisplayExtension("a group4");
1976 wsGroup.setExtension("aGroup4");
1977 wsGroup.setName("aStem:aGroup4");
1978 wsGroupToSave.setWsGroup(wsGroup);
1979 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1980
1981
1982 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
1983
1984 assertEquals("SUCCESS_INSERTED", resultCode);
1985 }
1986
1987 {
1988 WsGroupToSave wsGroupToSave = new WsGroupToSave();
1989 wsGroupToSave.setSaveMode("INSERT");
1990 wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
1991 WsGroup wsGroup = new WsGroup();
1992 wsGroup.setDisplayExtension("a group4");
1993 wsGroup.setExtension("aGroup4");
1994 wsGroup.setName("aStem:aGroup4");
1995 wsGroupToSave.setWsGroup(wsGroup);
1996 try {
1997 @SuppressWarnings("unused")
1998 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1999
2000 fail("Should not insert twice");
2001
2002
2003 } catch (GcWebServiceError gwse) {
2004 WsGroupSaveResults wsGroupSaveResults = (WsGroupSaveResults)gwse.getContainerResponseObject();
2005
2006 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2007
2008 assertEquals("GROUP_ALREADY_EXISTS", resultCode);
2009 }
2010 }
2011 }
2012
2013
2014
2015
2016
2017 public void testGroupSaveUpdateExistingName() throws Exception {
2018
2019 {
2020 WsGroupToSave wsGroupToSave = new WsGroupToSave();
2021 wsGroupToSave.setSaveMode("INSERT");
2022 wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
2023 WsGroup wsGroup = new WsGroup();
2024 wsGroup.setDisplayExtension("a group4");
2025 wsGroup.setExtension("aGroup4");
2026 wsGroup.setName("aStem:aGroup4");
2027 wsGroupToSave.setWsGroup(wsGroup);
2028 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
2029
2030
2031 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2032
2033 assertEquals("SUCCESS_INSERTED", resultCode);
2034 }
2035 String uuid = null;
2036 {
2037 WsGroupToSave wsGroupToSave = new WsGroupToSave();
2038 wsGroupToSave.setSaveMode("INSERT");
2039 wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
2040 WsGroup wsGroup = new WsGroup();
2041 wsGroup.setDisplayExtension("a group5");
2042 wsGroup.setExtension("aGroup5");
2043 wsGroup.setName("aStem:aGroup5");
2044 wsGroupToSave.setWsGroup(wsGroup);
2045 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
2046
2047 uuid = wsGroupSaveResults.getResults()[0].getWsGroup().getUuid();
2048
2049
2050 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2051
2052 assertEquals("SUCCESS_INSERTED", resultCode);
2053
2054 }
2055
2056 {
2057 WsGroupToSave wsGroupToSave = new WsGroupToSave();
2058 wsGroupToSave.setSaveMode("UPDATE");
2059 wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, uuid));
2060 WsGroup wsGroup = new WsGroup();
2061 wsGroup.setDisplayExtension("a group4");
2062 wsGroup.setExtension("aGroup4");
2063 wsGroup.setName("aStem:aGroup4");
2064 wsGroupToSave.setWsGroup(wsGroup);
2065 try {
2066 @SuppressWarnings("unused")
2067 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
2068
2069 fail("Should not update to existing name");
2070
2071
2072 } catch (GcWebServiceError gwse) {
2073 WsGroupSaveResults wsGroupSaveResults = (WsGroupSaveResults)gwse.getContainerResponseObject();
2074
2075 String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2076
2077 assertEquals("EXCEPTION", resultCode);
2078 }
2079 }
2080
2081 }
2082
2083
2084
2085
2086 public void testGroupSaveMoveCopy() throws Exception {
2087
2088 GrouperSession grouperSession = GrouperSession.startRootSession();
2089
2090 new GroupSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:testGroupToCopy").save();
2091
2092 Group group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", false);
2093
2094 if (group != null) {
2095 group.delete();
2096 }
2097
2098 Stem toStem = new StemSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:stemDestination").save();
2099
2100 PrintStream systemOut = System.out;
2101
2102 ByteArrayOutputStream baos = new ByteArrayOutputStream();
2103 System.setOut(new PrintStream(baos));
2104 String output = null;
2105 String[] outputLines = null;
2106 Pattern pattern = null;
2107 Matcher matcher = null;
2108 try {
2109
2110 GrouperClient.main(GrouperClientUtils.splitTrim(
2111 "--operation=groupSaveWs --name=test:testGroupToCopy --paramName0=moveOrCopy --paramValue0=copy "
2112 + "--paramName1=moveOrCopyToStemName --paramValue1=test:stemDestination "
2113 + "--paramName2=copyPrivilegesOfGroup --paramValue2=true "
2114 + "--paramName3=copyGroupAsPrivilege --paramValue3=true "
2115 + "--paramName4=copyListMembersOfGroup --paramValue4=true "
2116 + "--paramName5=copyListGroupAsMember --paramValue5=true "
2117 + "--paramName6=copyAttributes --paramValue6=true "
2118 + " ", " "));
2119 System.out.flush();
2120 output = new String(baos.toByteArray());
2121
2122 systemOut.println(output);
2123
2124 System.setOut(systemOut);
2125
2126 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2127
2128 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2129 matcher = pattern.matcher(outputLines[0]);
2130
2131 assertTrue(outputLines[0], matcher.matches());
2132
2133 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2134
2135
2136
2137 assertTrue(GrouperClientWs.mostRecentRequest,
2138 GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2139 && GrouperClientWs.mostRecentRequest.contains("copy"));
2140 assertTrue(GrouperClientWs.mostRecentRequest,
2141 GrouperClientWs.mostRecentRequest.contains("moveOrCopyToStemName")
2142 && GrouperClientWs.mostRecentRequest.contains("test:stemDestination"));
2143
2144 group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", false, new QueryOptions().secondLevelCache(false));
2145
2146 assertTrue(group != null);
2147
2148
2149
2150
2151 group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", true, new QueryOptions().secondLevelCache(false));
2152
2153 if (group != null) {
2154 group.delete();
2155 }
2156
2157 baos = new ByteArrayOutputStream();
2158 System.setOut(new PrintStream(baos));
2159
2160 GrouperClient.main(GrouperClientUtils.splitTrim(
2161 "--operation=groupSaveWs --name=test:testGroupToCopy --paramName0=moveOrCopy --paramValue0=move "
2162 + "--paramName1=moveOrCopyToStemUuid --paramValue1=" + toStem.getUuid() + " "
2163 + "--paramName2=moveAssignAlternateName --paramValue2=false", " "));
2164 System.out.flush();
2165 output = new String(baos.toByteArray());
2166
2167 System.setOut(systemOut);
2168
2169 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2170
2171 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2172 matcher = pattern.matcher(outputLines[0]);
2173
2174 assertTrue(outputLines[0], matcher.matches());
2175
2176 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2177
2178
2179
2180
2181 assertTrue(GrouperClientWs.mostRecentRequest,
2182 GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2183 && GrouperClientWs.mostRecentRequest.contains("move"));
2184 assertTrue(GrouperClientWs.mostRecentRequest,
2185 GrouperClientWs.mostRecentRequest.contains("moveAssignAlternateName")
2186 && GrouperClientWs.mostRecentRequest.contains(toStem.getUuid()));
2187
2188 group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", false, new QueryOptions().secondLevelCache(false));
2189
2190 assertTrue(group != null);
2191
2192 group = GroupFinder.findByName(grouperSession, "test:testGroupToCopy", false, new QueryOptions().secondLevelCache(false));
2193
2194 assertTrue(group == null);
2195
2196 } finally {
2197
2198 }
2199 }
2200
2201
2202
2203
2204 public void testStemSaveMoveCopy() throws Exception {
2205
2206 GrouperSession grouperSession = GrouperSession.startRootSession();
2207
2208 new StemSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:testStemToCopy").save();
2209
2210 Stem stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", false);
2211
2212 if (stemToCopy != null) {
2213 stemToCopy.delete();
2214 }
2215
2216 Stem toStem = new StemSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:stemDestination").save();
2217
2218 PrintStream systemOut = System.out;
2219
2220 ByteArrayOutputStream baos = new ByteArrayOutputStream();
2221 System.setOut(new PrintStream(baos));
2222 String output = null;
2223 String[] outputLines = null;
2224 Pattern pattern = null;
2225 Matcher matcher = null;
2226 try {
2227
2228 GrouperClient.main(GrouperClientUtils.splitTrim(
2229 "--operation=stemSaveWs --name=test:testStemToCopy --paramName0=moveOrCopy --paramValue0=copy "
2230 + "--paramName1=moveOrCopyToStemName --paramValue1=test:stemDestination "
2231 + "--paramName2=copyPrivilegesOfGroup --paramValue2=true "
2232 + "--paramName3=copyGroupAsPrivilege --paramValue3=true "
2233 + "--paramName4=copyListMembersOfGroup --paramValue4=true "
2234 + "--paramName5=copyListGroupAsMember --paramValue5=true "
2235 + "--paramName6=copyAttributes --paramValue6=true "
2236 + "--paramName7=copyPrivilegesOfStem --paramValue7=true"
2237 + " ", " "));
2238 System.out.flush();
2239 output = new String(baos.toByteArray());
2240
2241 systemOut.println(output);
2242
2243 System.setOut(systemOut);
2244
2245 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2246
2247 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2248 matcher = pattern.matcher(outputLines[0]);
2249
2250 assertTrue(outputLines[0], matcher.matches());
2251
2252 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2253
2254
2255
2256 assertTrue(GrouperClientWs.mostRecentRequest,
2257 GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2258 && GrouperClientWs.mostRecentRequest.contains("copy"));
2259 assertTrue(GrouperClientWs.mostRecentRequest,
2260 GrouperClientWs.mostRecentRequest.contains("moveOrCopyToStemName")
2261 && GrouperClientWs.mostRecentRequest.contains("test:stemDestination"));
2262
2263 stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", false, new QueryOptions().secondLevelCache(false));
2264
2265 assertTrue(stemToCopy != null);
2266
2267
2268
2269
2270 stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", true, new QueryOptions().secondLevelCache(false));
2271
2272 if (stemToCopy != null) {
2273 stemToCopy.delete();
2274 }
2275
2276 baos = new ByteArrayOutputStream();
2277 System.setOut(new PrintStream(baos));
2278
2279 GrouperClient.main(GrouperClientUtils.splitTrim(
2280 "--operation=stemSaveWs --name=test:testStemToCopy --paramName0=moveOrCopy --paramValue0=move "
2281 + "--paramName1=moveOrCopyToStemUuid --paramValue1=" + toStem.getUuid() + " "
2282 + "--paramName2=moveAssignAlternateName --paramValue2=false", " "));
2283 System.out.flush();
2284 output = new String(baos.toByteArray());
2285
2286 System.setOut(systemOut);
2287
2288 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2289
2290 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2291 matcher = pattern.matcher(outputLines[0]);
2292
2293 assertTrue(outputLines[0], matcher.matches());
2294
2295 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2296
2297
2298
2299
2300 assertTrue(GrouperClientWs.mostRecentRequest,
2301 GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2302 && GrouperClientWs.mostRecentRequest.contains("move"));
2303 assertTrue(GrouperClientWs.mostRecentRequest,
2304 GrouperClientWs.mostRecentRequest.contains("moveAssignAlternateName")
2305 && GrouperClientWs.mostRecentRequest.contains(toStem.getUuid()));
2306
2307 stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", false, new QueryOptions().secondLevelCache(false));
2308
2309 assertTrue(stemToCopy != null);
2310
2311 stemToCopy = StemFinder.findByName(grouperSession, "test:testStemToCopy", false, new QueryOptions().secondLevelCache(false));
2312
2313 assertTrue(stemToCopy == null);
2314
2315 } finally {
2316
2317 }
2318 }
2319
2320
2321
2322
2323 public void testGroupSave() throws Exception {
2324
2325 PrintStream systemOut = System.out;
2326
2327 ByteArrayOutputStream baos = new ByteArrayOutputStream();
2328 System.setOut(new PrintStream(baos));
2329 String output = null;
2330 String[] outputLines = null;
2331 Pattern pattern = null;
2332 Matcher matcher = null;
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343 try {
2344 systemOut.println("Umlaut: äöüß");
2345
2346 GrouperClient.main(GrouperClientUtils.splitTrim(
2347 "--operation=groupSaveWs --name=aStem:newGroup0äöüß", " "));
2348 System.out.flush();
2349 output = new String(baos.toByteArray());
2350
2351 systemOut.println(output);
2352
2353 System.setOut(systemOut);
2354
2355 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2356
2357 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2358 matcher = pattern.matcher(outputLines[0]);
2359
2360 assertTrue(outputLines[0], matcher.matches());
2361
2362 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2363 assertEquals("aStem:newGroup0äöüß", matcher.group(2));
2364
2365
2366
2367
2368 baos = new ByteArrayOutputStream();
2369 System.setOut(new PrintStream(baos));
2370
2371 GrouperClient.main(GrouperClientUtils.splitTrim(
2372 "--operation=groupSaveWs --name=aStem:newGroup0/1", " "));
2373 System.out.flush();
2374 output = new String(baos.toByteArray());
2375
2376 System.setOut(systemOut);
2377
2378 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2379
2380 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2381 matcher = pattern.matcher(outputLines[0]);
2382
2383 assertTrue(outputLines[0], matcher.matches());
2384
2385 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2386 assertEquals("aStem:newGroup0/1", matcher.group(2));
2387
2388
2389
2390
2391 baos = new ByteArrayOutputStream();
2392 System.setOut(new PrintStream(baos));
2393
2394 GrouperClient.main(GrouperClientUtils.splitTrim(
2395 "--operation=groupSaveWs --name=aStem:newGroup0", " "));
2396 System.out.flush();
2397 output = new String(baos.toByteArray());
2398
2399 System.setOut(systemOut);
2400
2401 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2402
2403 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2404 matcher = pattern.matcher(outputLines[0]);
2405
2406 assertTrue(outputLines[0], matcher.matches());
2407
2408 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2409 assertEquals("aStem:newGroup0", matcher.group(2));
2410
2411
2412
2413
2414 baos = new ByteArrayOutputStream();
2415 System.setOut(new PrintStream(baos));
2416
2417 GrouperClient
2418 .main(GrouperClientUtils
2419 .splitTrim(
2420 "--operation=groupSaveWs --name=aStem:newGroup0 --clientVersion=v1_3_000",
2421 " "));
2422 System.out.flush();
2423 output = new String(baos.toByteArray());
2424
2425 System.setOut(systemOut);
2426
2427 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2428
2429 matcher = pattern.matcher(outputLines[0]);
2430
2431 assertTrue(outputLines[0], matcher.matches());
2432
2433 assertEquals("SUCCESS", matcher.group(1));
2434 assertEquals("aStem:newGroup0", matcher.group(2));
2435
2436
2437
2438 baos = new ByteArrayOutputStream();
2439 System.setOut(new PrintStream(baos));
2440
2441 GrouperClient.main(GrouperClientUtils.splitTrim(
2442 "--operation=groupSaveWs --name=aStem:newGroup0", " "));
2443 System.out.flush();
2444 output = new String(baos.toByteArray());
2445
2446 System.setOut(systemOut);
2447
2448 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2449
2450 matcher = pattern.matcher(outputLines[0]);
2451
2452 assertTrue(outputLines[0], matcher.matches());
2453
2454 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2455 assertEquals("aStem:newGroup0", matcher.group(2));
2456
2457
2458
2459 baos = new ByteArrayOutputStream();
2460 System.setOut(new PrintStream(baos));
2461
2462 GrouperClient
2463 .main(GrouperClientUtils
2464 .splitTrim(
2465 "--operation=groupSaveWs --name=aStem:newGroup0 --displayExtension=newGroup0displayExtension",
2466 " "));
2467 System.out.flush();
2468 output = new String(baos.toByteArray());
2469
2470 System.setOut(systemOut);
2471
2472 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2473
2474 matcher = pattern.matcher(outputLines[0]);
2475
2476 assertTrue(outputLines[0], matcher.matches());
2477
2478 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2479 assertEquals("aStem:newGroup0", matcher.group(2));
2480
2481
2482
2483 baos = new ByteArrayOutputStream();
2484 System.setOut(new PrintStream(baos));
2485
2486
2487 try {
2488 GrouperClient
2489 .main(GrouperClientUtils
2490 .splitTrim(
2491 "--operation=groupSaveWs --name=aStem:newGroup0 --ousdfsdfate=${index}",
2492 " "));
2493 } catch (Exception e) {
2494 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
2495 }
2496 System.out.flush();
2497
2498 System.setOut(systemOut);
2499
2500
2501
2502 baos = new ByteArrayOutputStream();
2503 System.setOut(new PrintStream(baos));
2504
2505
2506 GrouperClient
2507 .main(GrouperClientUtils
2508 .splitTrim(
2509 "--operation=groupSaveWs --name=aStem:newGroup0 --outputTemplate=${index}",
2510 " "));
2511
2512 System.out.flush();
2513
2514 output = new String(baos.toByteArray());
2515
2516 System.setOut(systemOut);
2517
2518 assertEquals("0", output);
2519
2520
2521
2522 baos = new ByteArrayOutputStream();
2523 System.setOut(new PrintStream(baos));
2524
2525 GrouperClient.main(GrouperClientUtils.splitTrim(
2526 "--operation=groupSaveWs --name=aStem:newGroup0 --saveMode=UPDATE",
2527 " "));
2528 System.out.flush();
2529 output = new String(baos.toByteArray());
2530
2531 System.setOut(systemOut);
2532
2533 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2534
2535 matcher = pattern.matcher(outputLines[0]);
2536
2537 assertTrue(outputLines[0], matcher.matches());
2538
2539 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2540 assertEquals("aStem:newGroup0", matcher.group(2));
2541
2542 assertTrue(GrouperClientWs.mostRecentRequest,
2543 GrouperClientWs.mostRecentRequest.contains("saveMode")
2544 && GrouperClientWs.mostRecentRequest.contains("UPDATE"));
2545
2546
2547
2548 baos = new ByteArrayOutputStream();
2549 System.setOut(new PrintStream(baos));
2550
2551 GrouperClient.main(GrouperClientUtils.splitTrim(
2552 "--operation=groupSaveWs --name=aStem:newGroup0 --txType=NONE", " "));
2553 System.out.flush();
2554 output = new String(baos.toByteArray());
2555
2556 System.setOut(systemOut);
2557
2558 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2559
2560 matcher = pattern.matcher(outputLines[0]);
2561
2562 assertTrue(outputLines[0], matcher.matches());
2563
2564 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2565 assertEquals("aStem:newGroup0", matcher.group(2));
2566
2567 assertTrue(GrouperClientWs.mostRecentRequest,
2568 GrouperClientWs.mostRecentRequest.contains("txType")
2569 && GrouperClientWs.mostRecentRequest.contains("NONE")
2570 && !GrouperClientWs.mostRecentRequest
2571 .contains("includeGroupDetail"));
2572
2573
2574
2575 baos = new ByteArrayOutputStream();
2576 System.setOut(new PrintStream(baos));
2577
2578 GrouperClient
2579 .main(GrouperClientUtils
2580 .splitTrim(
2581 "--operation=groupSaveWs --name=aStem:newGroup0 --includeGroupDetail=true",
2582 " "));
2583 System.out.flush();
2584 output = new String(baos.toByteArray());
2585
2586 System.setOut(systemOut);
2587
2588 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2589
2590 matcher = pattern.matcher(outputLines[0]);
2591
2592 assertTrue(outputLines[0], matcher.matches());
2593
2594 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2595 assertEquals("aStem:newGroup0", matcher.group(2));
2596
2597 assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
2598 && !GrouperClientWs.mostRecentRequest.contains("NONE")
2599 && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
2600
2601
2602
2603 baos = new ByteArrayOutputStream();
2604 System.setOut(new PrintStream(baos));
2605
2606 GrouperClient
2607 .main(GrouperClientUtils
2608 .splitTrim(
2609 "--operation=groupSaveWs --name=aStem:newGroup1 --groupLookupName=aStem:newGroup0",
2610 " "));
2611 System.out.flush();
2612 output = new String(baos.toByteArray());
2613
2614 System.setOut(systemOut);
2615
2616 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2617
2618 matcher = pattern.matcher(outputLines[0]);
2619
2620 assertTrue(outputLines[0], matcher.matches());
2621
2622 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2623 assertEquals("aStem:newGroup1", matcher.group(2));
2624
2625 assertTrue(GrouperClientWs.mostRecentRequest,
2626 !GrouperClientWs.mostRecentRequest.contains("txType")
2627 && !GrouperClientWs.mostRecentRequest.contains("NONE")
2628 && !GrouperClientWs.mostRecentRequest
2629 .contains("includeGroupDetail")
2630 && GrouperClientWs.mostRecentRequest.contains("wsGroupLookup")
2631 && GrouperClientWs.mostRecentRequest.contains("aStem:newGroup1")
2632 && GrouperClientWs.mostRecentRequest.contains("aStem:newGroup0"));
2633
2634
2635
2636 baos = new ByteArrayOutputStream();
2637 System.setOut(new PrintStream(baos));
2638
2639 GrouperClient.main(GrouperClientUtils.splitTrim(
2640 "--operation=groupSaveWs --name=aStem:newGroup3 --saveMode=INSERT",
2641 " "));
2642 System.out.flush();
2643 output = new String(baos.toByteArray());
2644
2645 System.setOut(systemOut);
2646
2647 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2648
2649 matcher = pattern.matcher(outputLines[0]);
2650
2651 assertTrue(outputLines[0], matcher.matches());
2652
2653 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2654 assertEquals("aStem:newGroup3", matcher.group(2));
2655
2656 assertTrue(GrouperClientWs.mostRecentRequest.contains("saveMode")
2657 && GrouperClientWs.mostRecentRequest.contains("INSERT"));
2658
2659
2660
2661 baos = new ByteArrayOutputStream();
2662 System.setOut(new PrintStream(baos));
2663
2664 try {
2665 GrouperClient
2666 .main(GrouperClientUtils
2667 .splitTrim(
2668 "--operation=groupSaveWs --name=aStem:newGroup0 --description=aDescription",
2669 " "));
2670 System.out.flush();
2671 output = new String(baos.toByteArray());
2672
2673 System.setOut(systemOut);
2674
2675 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2676
2677 matcher = pattern.matcher(outputLines[0]);
2678
2679 assertTrue(outputLines[0], matcher.matches());
2680
2681 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2682 assertEquals("aStem:newGroup0", matcher.group(2));
2683
2684 assertTrue(GrouperClientWs.mostRecentRequest.contains("description")
2685 && GrouperClientWs.mostRecentRequest.contains("aDescription"));
2686
2687
2688
2689 baos = new ByteArrayOutputStream();
2690 System.setOut(new PrintStream(baos));
2691
2692 GrouperClient
2693 .main(GrouperClientUtils
2694 .splitTrim(
2695 "--operation=groupSaveWs --name=aStem:newGroup0 --paramName0=whatever --paramValue0=someValue",
2696 " "));
2697 System.out.flush();
2698 output = new String(baos.toByteArray());
2699
2700 System.setOut(systemOut);
2701
2702 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2703
2704 matcher = pattern.matcher(outputLines[0]);
2705
2706 assertTrue(outputLines[0], matcher.matches());
2707
2708 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2709 assertEquals("aStem:newGroup0", matcher.group(2));
2710
2711 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
2712 && GrouperClientWs.mostRecentRequest.contains("someValue"));
2713
2714
2715
2716 baos = new ByteArrayOutputStream();
2717 System.setOut(new PrintStream(baos));
2718
2719 GrouperClient.main(GrouperClientUtils.splitTrim(
2720 "--operation=groupSaveWs --name=aStem:newGroup0 --typeNames=aType",
2721 " "));
2722 System.out.flush();
2723 output = new String(baos.toByteArray());
2724
2725 System.setOut(systemOut);
2726
2727 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2728
2729 matcher = pattern.matcher(outputLines[0]);
2730
2731 assertTrue(outputLines[0], matcher.matches());
2732
2733 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2734 assertEquals("aStem:newGroup0", matcher.group(2));
2735
2736 assertTrue(GrouperClientWs.mostRecentRequest.contains("typeNames")
2737 && GrouperClientWs.mostRecentRequest.contains("aType"));
2738
2739
2740
2741 baos = new ByteArrayOutputStream();
2742 System.setOut(new PrintStream(baos));
2743
2744 GrouperClient
2745 .main(GrouperClientUtils
2746 .splitTrim(
2747 "--operation=groupSaveWs --name=aStem:newGroup0 --typeNames=aType --attributeName0=attr_1 --attributeValue0=whatever",
2748 " "));
2749 System.out.flush();
2750 output = new String(baos.toByteArray());
2751
2752 System.setOut(systemOut);
2753
2754 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2755
2756 matcher = pattern.matcher(outputLines[0]);
2757
2758 assertTrue(outputLines[0], matcher.matches());
2759
2760 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2761 assertEquals("aStem:newGroup0", matcher.group(2));
2762
2763 assertTrue(GrouperClientWs.mostRecentRequest.contains("attr_1")
2764 && GrouperClientWs.mostRecentRequest.contains("whatever"));
2765
2766
2767
2768 baos = new ByteArrayOutputStream();
2769 System.setOut(new PrintStream(baos));
2770
2771 GrouperClient
2772 .main(GrouperClientUtils
2773 .splitTrim(
2774 "--operation=groupSaveWs --name=aStem:newGroup0 --groupDetailParamName0=something --groupDetailParamValue0=whatever",
2775 " "));
2776 System.out.flush();
2777 output = new String(baos.toByteArray());
2778
2779 System.setOut(systemOut);
2780
2781 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2782
2783 matcher = pattern.matcher(outputLines[0]);
2784
2785 assertTrue(outputLines[0], matcher.matches());
2786
2787 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2788 assertEquals("aStem:newGroup0", matcher.group(2));
2789
2790 assertTrue(GrouperClientWs.mostRecentRequest.contains("something")
2791 && GrouperClientWs.mostRecentRequest.contains("whatever"));
2792
2793
2794
2795
2796 GrouperClient.main(GrouperClientUtils.splitTrim(
2797 "--operation=groupSaveWs --name=aStem:leftGroup", " "));
2798 GrouperClient.main(GrouperClientUtils.splitTrim(
2799 "--operation=groupSaveWs --name=aStem:rightGroup", " "));
2800
2801 baos = new ByteArrayOutputStream();
2802 System.setOut(new PrintStream(baos));
2803
2804 GrouperClient
2805 .main(GrouperClientUtils
2806 .splitTrim(
2807 "--operation=groupSaveWs --name=aStem:newGroup0 --compositeType=union --leftGroupName=aStem:leftGroup --rightGroupName=aStem:rightGroup --includeGroupDetail=true",
2808 " "));
2809 System.out.flush();
2810 output = new String(baos.toByteArray());
2811
2812 System.setOut(systemOut);
2813
2814 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2815
2816 matcher = pattern.matcher(outputLines[0]);
2817
2818 assertTrue(outputLines[0], matcher.matches());
2819
2820 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2821 assertEquals("aStem:newGroup0", matcher.group(2));
2822
2823 assertTrue(GrouperClientWs.mostRecentRequest.contains("union")
2824 && GrouperClientWs.mostRecentRequest.contains("aStem:leftGroup")
2825 && GrouperClientWs.mostRecentRequest.contains("aStem:rightGroup"));
2826
2827
2828
2829
2830 baos = new ByteArrayOutputStream();
2831 System.setOut(new PrintStream(baos));
2832
2833 GrouperClient
2834 .main(GrouperClientUtils
2835 .splitTrim(
2836 "--operation=groupSaveWs --name=aStem:newGroup4 --typeOfGroup=entity",
2837 " "));
2838 System.out.flush();
2839 output = new String(baos.toByteArray());
2840
2841 System.setOut(systemOut);
2842
2843 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2844
2845 matcher = pattern.matcher(outputLines[0]);
2846
2847 assertTrue(outputLines[0], matcher.matches());
2848
2849 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2850 assertEquals("aStem:newGroup4", matcher.group(2));
2851
2852 assertTrue(GrouperClientWs.mostRecentRequest, GrouperClientWs.mostRecentRequest.contains("<typeOfGroup>entity</typeOfGroup>"));
2853
2854
2855
2856
2857 baos = new ByteArrayOutputStream();
2858 System.setOut(new PrintStream(baos));
2859
2860 GrouperClient
2861 .main(GrouperClientUtils
2862 .splitTrim(
2863 "--operation=groupSaveWs --name=aStem:newGroup5 --idIndex=12345",
2864 " "));
2865 System.out.flush();
2866 output = new String(baos.toByteArray());
2867
2868 System.setOut(systemOut);
2869
2870 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2871
2872 matcher = pattern.matcher(outputLines[0]);
2873
2874 assertTrue(outputLines[0], matcher.matches());
2875
2876 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2877 assertEquals("aStem:newGroup5", matcher.group(2));
2878
2879 assertTrue(GrouperClientWs.mostRecentRequest, GrouperClientWs.mostRecentRequest.contains("<idIndex>12345</idIndex>"));
2880 assertTrue(GrouperClientWs.mostRecentResponse, GrouperClientWs.mostRecentResponse.contains("<idIndex>12345</idIndex>"));
2881
2882
2883
2884 baos = new ByteArrayOutputStream();
2885 System.setOut(new PrintStream(baos));
2886
2887 GrouperClient
2888 .main(GrouperClientUtils
2889 .splitTrim(
2890 "--operation=groupSaveWs --name=aStem:newGroup5 --groupLookupIdIndex=12345 --description=newDescription",
2891 " "));
2892 System.out.flush();
2893 output = new String(baos.toByteArray());
2894
2895 System.setOut(systemOut);
2896
2897 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2898
2899 matcher = pattern.matcher(outputLines[0]);
2900
2901 assertTrue(outputLines[0], matcher.matches());
2902
2903 assertEquals("SUCCESS_UPDATED", matcher.group(1));
2904 assertEquals("aStem:newGroup5", matcher.group(2));
2905
2906 assertTrue(GrouperClientWs.mostRecentRequest, GrouperClientWs.mostRecentRequest.contains("<idIndex>12345</idIndex>"));
2907 assertTrue(GrouperClientWs.mostRecentResponse, GrouperClientWs.mostRecentResponse.contains("<idIndex>12345</idIndex>"));
2908
2909
2910 } finally {
2911 }
2912 } finally {
2913 System.setOut(systemOut);
2914 }
2915
2916 }
2917
2918
2919
2920
2921 public void testStemSave() throws Exception {
2922
2923 PrintStream systemOut = System.out;
2924
2925 ByteArrayOutputStream baos = new ByteArrayOutputStream();
2926 System.setOut(new PrintStream(baos));
2927
2928 GrouperSession grouperSession = GrouperSession.startRootSession();
2929 Stem someStem = new StemSave(grouperSession).assignName("someStem").save();
2930 GrouperSession.stopQuietly(grouperSession);
2931 try {
2932
2933 GrouperClient.main(GrouperClientUtils.splitTrim(
2934 "--operation=stemSaveWs --name=aStem:newStem0", " "));
2935 System.out.flush();
2936 String output = new String(baos.toByteArray());
2937
2938 System.setOut(systemOut);
2939
2940 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
2941
2942 Pattern pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2943 Matcher matcher = pattern.matcher(outputLines[0]);
2944
2945 assertTrue(outputLines[0], matcher.matches());
2946
2947 assertEquals("SUCCESS_INSERTED", matcher.group(1));
2948 assertEquals("aStem:newStem0", matcher.group(2));
2949
2950
2951
2952
2953 baos = new ByteArrayOutputStream();
2954 System.setOut(new PrintStream(baos));
2955
2956 GrouperClient
2957 .main(GrouperClientUtils
2958 .splitTrim(
2959 "--operation=stemSaveWs --name=aStem:newStem0 --clientVersion=v1_3_000",
2960 " "));
2961 System.out.flush();
2962 output = new String(baos.toByteArray());
2963
2964 System.setOut(systemOut);
2965
2966 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2967
2968 matcher = pattern.matcher(outputLines[0]);
2969
2970 assertTrue(outputLines[0], matcher.matches());
2971
2972 assertEquals("SUCCESS", matcher.group(1));
2973 assertEquals("aStem:newStem0", matcher.group(2));
2974
2975
2976
2977 baos = new ByteArrayOutputStream();
2978 System.setOut(new PrintStream(baos));
2979
2980 GrouperClient.main(GrouperClientUtils.splitTrim(
2981 "--operation=stemSaveWs --name=aStem:newStem0", " "));
2982 System.out.flush();
2983 output = new String(baos.toByteArray());
2984
2985 System.setOut(systemOut);
2986
2987 outputLines = GrouperClientUtils.splitTrim(output, "\n");
2988
2989 matcher = pattern.matcher(outputLines[0]);
2990
2991 assertTrue(outputLines[0], matcher.matches());
2992
2993 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2994 assertEquals("aStem:newStem0", matcher.group(2));
2995
2996
2997
2998 baos = new ByteArrayOutputStream();
2999 System.setOut(new PrintStream(baos));
3000
3001 GrouperClient
3002 .main(GrouperClientUtils
3003 .splitTrim(
3004 "--operation=stemSaveWs --name=aStem:newStem0 --displayExtension=newStem0displayExtension",
3005 " "));
3006 System.out.flush();
3007 output = new String(baos.toByteArray());
3008
3009 System.setOut(systemOut);
3010
3011 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3012
3013 matcher = pattern.matcher(outputLines[0]);
3014
3015 assertTrue(outputLines[0], matcher.matches());
3016
3017 assertEquals("SUCCESS_UPDATED", matcher.group(1));
3018 assertEquals("aStem:newStem0", matcher.group(2));
3019
3020
3021
3022 baos = new ByteArrayOutputStream();
3023 System.setOut(new PrintStream(baos));
3024
3025
3026 try {
3027 GrouperClient
3028 .main(GrouperClientUtils
3029 .splitTrim(
3030 "--operation=stemSaveWs --name=aStem:newStem0 --ousdfsdfate=${index}",
3031 " "));
3032 } catch (Exception e) {
3033 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
3034 }
3035 System.out.flush();
3036
3037 System.setOut(systemOut);
3038
3039
3040
3041 baos = new ByteArrayOutputStream();
3042 System.setOut(new PrintStream(baos));
3043
3044
3045 GrouperClient
3046 .main(GrouperClientUtils
3047 .splitTrim(
3048 "--operation=stemSaveWs --name=aStem:newStem0 --outputTemplate=${index}",
3049 " "));
3050
3051 System.out.flush();
3052
3053 output = new String(baos.toByteArray());
3054
3055 System.setOut(systemOut);
3056
3057 assertEquals("0", output);
3058
3059
3060
3061 baos = new ByteArrayOutputStream();
3062 System.setOut(new PrintStream(baos));
3063
3064
3065 GrouperClient
3066 .main(GrouperClientUtils
3067 .splitTrim(
3068 "--operation=stemSaveWs --name=aStem:newStem0 --outputTemplate=a${grouperClientUtils.defaultString(wsStemSaveResult.resultMetadata.resfsdfCode)}",
3069 " "));
3070
3071 System.out.flush();
3072
3073 output = new String(baos.toByteArray());
3074
3075 System.setOut(systemOut);
3076
3077 assertEquals("a", output);
3078
3079
3080
3081 baos = new ByteArrayOutputStream();
3082 System.setOut(new PrintStream(baos));
3083
3084 GrouperClient.main(GrouperClientUtils
3085 .splitTrim(
3086 "--operation=stemSaveWs --name=aStem:newStem0 --saveMode=UPDATE",
3087 " "));
3088 System.out.flush();
3089 output = new String(baos.toByteArray());
3090
3091 System.setOut(systemOut);
3092
3093 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3094
3095 matcher = pattern.matcher(outputLines[0]);
3096
3097 assertTrue(outputLines[0], matcher.matches());
3098
3099 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
3100 assertEquals("aStem:newStem0", matcher.group(2));
3101
3102 assertTrue(GrouperClientWs.mostRecentRequest,
3103 GrouperClientWs.mostRecentRequest.contains("saveMode")
3104 && GrouperClientWs.mostRecentRequest.contains("UPDATE"));
3105
3106
3107
3108 baos = new ByteArrayOutputStream();
3109 System.setOut(new PrintStream(baos));
3110
3111 GrouperClient.main(GrouperClientUtils.splitTrim(
3112 "--operation=stemSaveWs --name=aStem:newStem0 --txType=NONE", " "));
3113 System.out.flush();
3114 output = new String(baos.toByteArray());
3115
3116 System.setOut(systemOut);
3117
3118 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3119
3120 matcher = pattern.matcher(outputLines[0]);
3121
3122 assertTrue(outputLines[0], matcher.matches());
3123
3124 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
3125 assertEquals("aStem:newStem0", matcher.group(2));
3126
3127 assertTrue(GrouperClientWs.mostRecentRequest,
3128 GrouperClientWs.mostRecentRequest.contains("txType")
3129 && GrouperClientWs.mostRecentRequest.contains("NONE")
3130 && !GrouperClientWs.mostRecentRequest
3131 .contains("includeGroupDetail"));
3132
3133
3134
3135 baos = new ByteArrayOutputStream();
3136 System.setOut(new PrintStream(baos));
3137
3138 GrouperClient
3139 .main(GrouperClientUtils
3140 .splitTrim(
3141 "--operation=stemSaveWs --name=aStem:newStem1 --stemLookupName=aStem:newStem0",
3142 " "));
3143 System.out.flush();
3144 output = new String(baos.toByteArray());
3145
3146 System.setOut(systemOut);
3147
3148 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3149
3150 matcher = pattern.matcher(outputLines[0]);
3151
3152 assertTrue(outputLines[0], matcher.matches());
3153
3154 assertEquals("SUCCESS_UPDATED", matcher.group(1));
3155 assertEquals("aStem:newStem1", matcher.group(2));
3156
3157 assertTrue(GrouperClientWs.mostRecentRequest,
3158 GrouperClientWs.mostRecentRequest.contains("wsStemLookup")
3159 && GrouperClientWs.mostRecentRequest.contains("aStem:newStem1")
3160 && GrouperClientWs.mostRecentRequest.contains("aStem:newStem0"));
3161
3162
3163 grouperSession = GrouperSession.startRootSession();
3164 try {
3165 Stem stem = StemFinder.findByName(grouperSession, "aStem:newStem0", true, new QueryOptions().secondLevelCache(false));
3166 stem.delete();
3167 } finally {
3168 GrouperSession.stopQuietly(grouperSession);
3169 }
3170
3171
3172
3173 baos = new ByteArrayOutputStream();
3174 System.setOut(new PrintStream(baos));
3175
3176 GrouperClient.main(GrouperClientUtils
3177 .splitTrim(
3178 "--operation=stemSaveWs --name=aStem:newStem0 --saveMode=INSERT",
3179 " "));
3180 System.out.flush();
3181 output = new String(baos.toByteArray());
3182
3183 System.setOut(systemOut);
3184
3185 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3186
3187 matcher = pattern.matcher(outputLines[0]);
3188
3189 assertTrue(outputLines[0], matcher.matches());
3190
3191 assertEquals("SUCCESS_INSERTED", matcher.group(1));
3192 assertEquals("aStem:newStem0", matcher.group(2));
3193
3194 assertTrue(GrouperClientWs.mostRecentRequest.contains("saveMode")
3195 && GrouperClientWs.mostRecentRequest.contains("INSERT"));
3196
3197
3198
3199 baos = new ByteArrayOutputStream();
3200 System.setOut(new PrintStream(baos));
3201
3202 GrouperClient
3203 .main(GrouperClientUtils
3204 .splitTrim(
3205 "--operation=stemSaveWs --name=aStem:newStem0 --description=aDescription",
3206 " "));
3207 System.out.flush();
3208 output = new String(baos.toByteArray());
3209
3210 System.setOut(systemOut);
3211
3212 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3213
3214 matcher = pattern.matcher(outputLines[0]);
3215
3216 assertTrue(outputLines[0], matcher.matches());
3217
3218 assertEquals("SUCCESS_UPDATED", matcher.group(1));
3219 assertEquals("aStem:newStem0", matcher.group(2));
3220
3221 assertTrue(GrouperClientWs.mostRecentRequest.contains("description")
3222 && GrouperClientWs.mostRecentRequest.contains("aDescription"));
3223
3224
3225
3226 baos = new ByteArrayOutputStream();
3227 System.setOut(new PrintStream(baos));
3228
3229 GrouperClient
3230 .main(GrouperClientUtils
3231 .splitTrim(
3232 "--operation=stemSaveWs --name=aStem:newStem0 --paramName0=whatever --paramValue0=someValue",
3233 " "));
3234 System.out.flush();
3235 output = new String(baos.toByteArray());
3236
3237 System.setOut(systemOut);
3238
3239 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3240
3241 matcher = pattern.matcher(outputLines[0]);
3242
3243 assertTrue(outputLines[0], matcher.matches());
3244
3245 assertEquals("SUCCESS_UPDATED", matcher.group(1));
3246 assertEquals("aStem:newStem0", matcher.group(2));
3247
3248 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
3249 && GrouperClientWs.mostRecentRequest.contains("someValue"));
3250
3251
3252
3253 baos = new ByteArrayOutputStream();
3254 System.setOut(new PrintStream(baos));
3255
3256 GrouperClient
3257 .main(GrouperClientUtils
3258 .splitTrim(
3259 "--operation=stemSaveWs --name=aStem:newStem5 --idIndex=12345",
3260 " "));
3261 System.out.flush();
3262 output = new String(baos.toByteArray());
3263
3264 System.setOut(systemOut);
3265
3266 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3267
3268 matcher = pattern.matcher(outputLines[0]);
3269
3270 assertTrue(outputLines[0], matcher.matches());
3271
3272 assertEquals("SUCCESS_INSERTED", matcher.group(1));
3273 assertEquals("aStem:newStem5", matcher.group(2));
3274
3275 assertTrue(GrouperClientWs.mostRecentRequest.contains("idIndex"));
3276
3277
3278
3279
3280 baos = new ByteArrayOutputStream();
3281 System.setOut(new PrintStream(baos));
3282
3283 GrouperClient
3284 .main(GrouperClientUtils
3285 .splitTrim(
3286 "--operation=stemSaveWs --name=someStem --description=myDescription --stemLookupIdIndex=" + someStem.getIdIndex(),
3287 " "));
3288 System.out.flush();
3289 output = new String(baos.toByteArray());
3290
3291 System.setOut(systemOut);
3292
3293 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3294
3295 matcher = pattern.matcher(outputLines[0]);
3296
3297 assertTrue(outputLines[0], matcher.matches());
3298
3299 assertEquals("SUCCESS_UPDATED", matcher.group(1));
3300 assertEquals("someStem", matcher.group(2));
3301
3302 assertTrue(GrouperClientWs.mostRecentRequest.contains("idIndex"));
3303
3304 } finally {
3305 System.setOut(systemOut);
3306 }
3307
3308 }
3309
3310
3311
3312
3313 public void testGetGroups() throws Exception {
3314
3315
3316 GrouperSession grouperSession = GrouperSession.startRootSession();
3317 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
3318 "aStem:aGroup", "aGroup", null, null, true);
3319 Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
3320 "aStem:aGroup2", "aGroup2", null, null, true);
3321 Group group3 = Group.saveGroup(grouperSession, "aStem:aGroup3", null,
3322 "aStem:aGroup3", "aGroup3", null, null, true);
3323 Group group4 = Group.saveGroup(grouperSession, "aStem:aGroup4", null,
3324 "aStem:aGroup4", "aGroup4", null, null, true);
3325 Group group5 = Group.saveGroup(grouperSession, "aStem:aGroup5", null,
3326 "aStem:aGroup5", "aGroup5", null, null, true);
3327 Group group6 = Group.saveGroup(grouperSession, "aStem:aGroup6", null,
3328 "aStem:aGroup6", "aGroup6", null, null, true);
3329
3330
3331 String wsUserLabel = GrouperClientUtils.propertiesValue(
3332 "grouperClient.webService.user.label", true);
3333 String wsUserString = GrouperClientUtils.propertiesValue(
3334 "grouperClient.webService." + wsUserLabel, true);
3335 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
3336
3337 group.grantPriv(wsUser, AccessPrivilege.READ, false);
3338 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3339 group2.grantPriv(wsUser, AccessPrivilege.READ, false);
3340 group2.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3341 group3.grantPriv(wsUser, AccessPrivilege.READ, false);
3342 group3.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3343 group4.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3344 group4.grantPriv(wsUser, AccessPrivilege.READ, false);
3345 group5.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3346 group5.grantPriv(wsUser, AccessPrivilege.READ, false);
3347 group6.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3348 group6.grantPriv(wsUser, AccessPrivilege.READ, false);
3349
3350
3351 group4.addMember(SubjectTestHelper.SUBJ0, false);
3352 group4.deleteMember(SubjectTestHelper.SUBJ0, false);
3353 Thread.sleep(100);
3354 Timestamp pointInTimeFrom = new Timestamp(new Date().getTime());
3355 Thread.sleep(100);
3356
3357
3358 group.addMember(SubjectTestHelper.SUBJ0, false);
3359 group2.addMember(SubjectTestHelper.SUBJ0, false);
3360 group2.addMember(SubjectTestHelper.SUBJ1, false);
3361 group3.addMember(SubjectTestHelper.SUBJ1, false);
3362
3363
3364 group5.addMember(SubjectTestHelper.SUBJ0, false);
3365 group5.deleteMember(SubjectTestHelper.SUBJ0, false);
3366 Thread.sleep(100);
3367 Timestamp pointInTimeTo = new Timestamp(new Date().getTime());
3368 Thread.sleep(100);
3369 group6.addMember(SubjectTestHelper.SUBJ0, false);
3370 group6.deleteMember(SubjectTestHelper.SUBJ0, false);
3371 ChangeLogTempToEntity.convertRecords();
3372
3373
3374 PrintStream systemOut = System.out;
3375
3376 ByteArrayOutputStream baos = new ByteArrayOutputStream();
3377 System.setOut(new PrintStream(baos));
3378
3379 try {
3380
3381 GrouperClient.main(GrouperClientUtils.splitTrim(
3382 "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1",
3383 " "));
3384 System.out.flush();
3385 String output = new String(baos.toByteArray());
3386
3387 System.setOut(systemOut);
3388
3389 System.out.println(output);
3390
3391 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
3392
3393 Pattern pattern = Pattern
3394 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
3395 Matcher matcher = pattern.matcher(outputLines[0]);
3396
3397 assertTrue(outputLines[0], matcher.matches());
3398
3399 assertEquals("0", matcher.group(1));
3400 assertEquals("SUCCESS", matcher.group(2));
3401 assertEquals("test.subject.0", matcher.group(3));
3402 assertEquals("0", matcher.group(4));
3403 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3404 matcher.group(5))
3405 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3406
3407 matcher = pattern.matcher(outputLines[1]);
3408
3409 assertTrue(outputLines[1], matcher.matches());
3410
3411 assertEquals("0", matcher.group(1));
3412 assertEquals("SUCCESS", matcher.group(2));
3413 assertEquals("test.subject.0", matcher.group(3));
3414 assertEquals("1", matcher.group(4));
3415 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3416 matcher.group(5))
3417 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3418
3419 matcher = pattern.matcher(outputLines[2]);
3420
3421 assertTrue(outputLines[2], matcher.matches());
3422
3423 assertEquals("1", matcher.group(1));
3424 assertEquals("SUCCESS", matcher.group(2));
3425 assertEquals("test.subject.1", matcher.group(3));
3426 assertEquals("0", matcher.group(4));
3427 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3428 matcher.group(5))
3429 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3430
3431 matcher = pattern.matcher(outputLines[3]);
3432
3433 assertTrue(outputLines[3], matcher.matches());
3434
3435 assertEquals("1", matcher.group(1));
3436 assertEquals("SUCCESS", matcher.group(2));
3437 assertEquals("test.subject.1", matcher.group(3));
3438 assertEquals("1", matcher.group(4));
3439 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3440 matcher.group(5))
3441 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3442
3443
3444
3445
3446 baos = new ByteArrayOutputStream();
3447 System.setOut(new PrintStream(baos));
3448
3449 ArrayList<String> args = new ArrayList<String>();
3450 args.add("--operation=getGroupsWs");
3451 args.add("--subjectIds=test.subject.0,test.subject.1");
3452 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTimeFrom));
3453 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTimeTo));
3454 GrouperClient.main(args.toArray(new String[0]));
3455
3456 System.out.flush();
3457 output = new String(baos.toByteArray());
3458
3459 System.setOut(systemOut);
3460
3461 System.out.println(output);
3462
3463 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3464
3465 matcher = pattern.matcher(outputLines[0]);
3466
3467 assertTrue(outputLines[0], matcher.matches());
3468
3469 assertEquals("0", matcher.group(1));
3470 assertEquals("SUCCESS", matcher.group(2));
3471 assertEquals("test.subject.0", matcher.group(3));
3472 assertEquals("0", matcher.group(4));
3473 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup", matcher.group(5))
3474 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5))
3475 || GrouperClientUtils.equals("aStem:aGroup5", matcher.group(5)));
3476
3477 matcher = pattern.matcher(outputLines[1]);
3478
3479 assertTrue(outputLines[1], matcher.matches());
3480
3481 assertEquals("0", matcher.group(1));
3482 assertEquals("SUCCESS", matcher.group(2));
3483 assertEquals("test.subject.0", matcher.group(3));
3484 assertEquals("1", matcher.group(4));
3485 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup", matcher.group(5))
3486 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5))
3487 || GrouperClientUtils.equals("aStem:aGroup5", matcher.group(5)));
3488
3489 matcher = pattern.matcher(outputLines[2]);
3490
3491 assertTrue(outputLines[2], matcher.matches());
3492
3493 assertEquals("0", matcher.group(1));
3494 assertEquals("SUCCESS", matcher.group(2));
3495 assertEquals("test.subject.0", matcher.group(3));
3496 assertEquals("2", matcher.group(4));
3497 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup", matcher.group(5))
3498 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5))
3499 || GrouperClientUtils.equals("aStem:aGroup5", matcher.group(5)));
3500
3501 matcher = pattern.matcher(outputLines[3]);
3502
3503 assertTrue(outputLines[3], matcher.matches());
3504
3505 assertEquals("1", matcher.group(1));
3506 assertEquals("SUCCESS", matcher.group(2));
3507 assertEquals("test.subject.1", matcher.group(3));
3508 assertEquals("0", matcher.group(4));
3509 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3510 matcher.group(5))
3511 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3512
3513 matcher = pattern.matcher(outputLines[4]);
3514
3515 assertTrue(outputLines[4], matcher.matches());
3516
3517 assertEquals("1", matcher.group(1));
3518 assertEquals("SUCCESS", matcher.group(2));
3519 assertEquals("test.subject.1", matcher.group(3));
3520 assertEquals("1", matcher.group(4));
3521 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3522 matcher.group(5))
3523 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3524
3525
3526
3527 baos = new ByteArrayOutputStream();
3528 System.setOut(new PrintStream(baos));
3529
3530
3531 try {
3532 GrouperClient
3533 .main(GrouperClientUtils
3534 .splitTrim(
3535 "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=whatever",
3536 " "));
3537 } catch (Exception e) {
3538 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
3539 }
3540 System.out.flush();
3541
3542 System.setOut(systemOut);
3543
3544
3545
3546 baos = new ByteArrayOutputStream();
3547 System.setOut(new PrintStream(baos));
3548
3549
3550 GrouperClient
3551 .main(GrouperClientUtils
3552 .splitTrim(
3553 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${subjectIndex}",
3554 " "));
3555
3556 System.out.flush();
3557
3558 output = new String(baos.toByteArray());
3559
3560 System.setOut(systemOut);
3561
3562 assertEquals("0011", output);
3563
3564
3565
3566 baos = new ByteArrayOutputStream();
3567 System.setOut(new PrintStream(baos));
3568
3569 GrouperClient
3570 .main(GrouperClientUtils
3571 .splitTrim(
3572 "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
3573 " "));
3574 System.out.flush();
3575 output = new String(baos.toByteArray());
3576
3577 System.setOut(systemOut);
3578
3579 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3580
3581 matcher = pattern.matcher(outputLines[0]);
3582
3583 assertTrue(outputLines[0], matcher.matches());
3584
3585 assertEquals("0", matcher.group(1));
3586 assertEquals("SUCCESS", matcher.group(2));
3587 assertEquals("test.subject.0", matcher.group(3));
3588 assertEquals("0", matcher.group(4));
3589 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3590 matcher.group(5))
3591 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3592
3593 matcher = pattern.matcher(outputLines[1]);
3594
3595 assertTrue(outputLines[1], matcher.matches());
3596
3597 assertEquals("0", matcher.group(1));
3598 assertEquals("SUCCESS", matcher.group(2));
3599 assertEquals("test.subject.0", matcher.group(3));
3600 assertEquals("1", matcher.group(4));
3601 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3602 matcher.group(5))
3603 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3604
3605 matcher = pattern.matcher(outputLines[2]);
3606
3607 assertTrue(outputLines[2], matcher.matches());
3608
3609 assertEquals("1", matcher.group(1));
3610 assertEquals("SUCCESS", matcher.group(2));
3611 assertEquals("test.subject.1", matcher.group(3));
3612 assertEquals("0", matcher.group(4));
3613 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3614 matcher.group(5))
3615 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3616
3617 matcher = pattern.matcher(outputLines[3]);
3618
3619 assertTrue(outputLines[3], matcher.matches());
3620
3621 assertEquals("1", matcher.group(1));
3622 assertEquals("SUCCESS", matcher.group(2));
3623 assertEquals("test.subject.1", matcher.group(3));
3624 assertEquals("1", matcher.group(4));
3625 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3626 matcher.group(5))
3627 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3628
3629 assertTrue(GrouperClientWs.mostRecentRequest
3630 .contains("includeGroupDetail")
3631 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
3632
3633
3634
3635 baos = new ByteArrayOutputStream();
3636 System.setOut(new PrintStream(baos));
3637
3638 GrouperClient
3639 .main(GrouperClientUtils
3640 .splitTrim(
3641 "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${subjectIndex}:$space$${wsGetGroupsResult.wsSubject.getAttributeValue(0)}$newline$",
3642 " "));
3643 System.out.flush();
3644 output = new String(baos.toByteArray());
3645
3646 System.setOut(systemOut);
3647
3648 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3649
3650 assertTrue(output, outputLines[0].contains("my name is test.subject.0"));
3651
3652 assertTrue(output, outputLines[2].contains("my name is test.subject.1"));
3653
3654 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
3655 assertTrue(GrouperClientWs.mostRecentResponse
3656 .contains("my name is test.subject.0"));
3657
3658
3659
3660 baos = new ByteArrayOutputStream();
3661 System.setOut(new PrintStream(baos));
3662
3663 GrouperClient
3664 .main(GrouperClientUtils
3665 .splitTrim(
3666 "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
3667 " "));
3668 System.out.flush();
3669 output = new String(baos.toByteArray());
3670
3671 System.setOut(systemOut);
3672
3673 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3674
3675 matcher = pattern.matcher(outputLines[0]);
3676
3677 assertTrue(outputLines[0], matcher.matches());
3678
3679 assertEquals("0", matcher.group(1));
3680 assertEquals("SUCCESS", matcher.group(2));
3681 assertEquals("test.subject.0", matcher.group(3));
3682 assertEquals("0", matcher.group(4));
3683 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3684 matcher.group(5))
3685 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3686
3687 matcher = pattern.matcher(outputLines[1]);
3688
3689 assertTrue(outputLines[1], matcher.matches());
3690
3691 assertEquals("0", matcher.group(1));
3692 assertEquals("SUCCESS", matcher.group(2));
3693 assertEquals("test.subject.0", matcher.group(3));
3694 assertEquals("1", matcher.group(4));
3695 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3696 matcher.group(5))
3697 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3698
3699 matcher = pattern.matcher(outputLines[2]);
3700
3701 assertTrue(outputLines[2], matcher.matches());
3702
3703 assertEquals("1", matcher.group(1));
3704 assertEquals("SUCCESS", matcher.group(2));
3705 assertEquals("test.subject.1", matcher.group(3));
3706 assertEquals("0", matcher.group(4));
3707 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3708 matcher.group(5))
3709 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3710
3711 matcher = pattern.matcher(outputLines[3]);
3712
3713 assertTrue(outputLines[3], matcher.matches());
3714
3715 assertEquals("1", matcher.group(1));
3716 assertEquals("SUCCESS", matcher.group(2));
3717 assertEquals("test.subject.1", matcher.group(3));
3718 assertEquals("1", matcher.group(4));
3719 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3720 matcher.group(5))
3721 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3722
3723 assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
3724
3725
3726
3727 baos = new ByteArrayOutputStream();
3728 System.setOut(new PrintStream(baos));
3729
3730 String subjectIdsFileName = "subjectIdsFile_"
3731 + GrouperClientUtils.uniqueId() + ".txt";
3732 File subjectIdsFile = new File(subjectIdsFileName);
3733
3734 GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
3735 "test.subject.0\ntest.subject.1");
3736
3737 try {
3738 GrouperClient.main(GrouperClientUtils.splitTrim(
3739 "--operation=getGroupsWs --subjectIdsFile=" + subjectIdsFileName,
3740 " "));
3741 System.out.flush();
3742 output = new String(baos.toByteArray());
3743
3744 System.setOut(systemOut);
3745
3746 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3747
3748 matcher = pattern.matcher(outputLines[0]);
3749
3750 matcher = pattern.matcher(outputLines[0]);
3751
3752 assertTrue(outputLines[0], matcher.matches());
3753
3754 assertEquals("0", matcher.group(1));
3755 assertEquals("SUCCESS", matcher.group(2));
3756 assertEquals("test.subject.0", matcher.group(3));
3757 assertEquals("0", matcher.group(4));
3758 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3759 matcher.group(5))
3760 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3761
3762 matcher = pattern.matcher(outputLines[1]);
3763
3764 assertTrue(outputLines[1], matcher.matches());
3765
3766 assertEquals("0", matcher.group(1));
3767 assertEquals("SUCCESS", matcher.group(2));
3768 assertEquals("test.subject.0", matcher.group(3));
3769 assertEquals("1", matcher.group(4));
3770 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3771 matcher.group(5))
3772 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3773
3774 matcher = pattern.matcher(outputLines[2]);
3775
3776 assertTrue(outputLines[2], matcher.matches());
3777
3778 assertEquals("1", matcher.group(1));
3779 assertEquals("SUCCESS", matcher.group(2));
3780 assertEquals("test.subject.1", matcher.group(3));
3781 assertEquals("0", matcher.group(4));
3782 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3783 matcher.group(5))
3784 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3785
3786 matcher = pattern.matcher(outputLines[3]);
3787
3788 assertTrue(outputLines[3], matcher.matches());
3789
3790 assertEquals("1", matcher.group(1));
3791 assertEquals("SUCCESS", matcher.group(2));
3792 assertEquals("test.subject.1", matcher.group(3));
3793 assertEquals("1", matcher.group(4));
3794 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3795 matcher.group(5))
3796 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3797
3798
3799
3800 baos = new ByteArrayOutputStream();
3801 System.setOut(new PrintStream(baos));
3802
3803 GrouperClient
3804 .main(GrouperClientUtils
3805 .splitTrim(
3806 "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --memberFilter=Immediate",
3807 " "));
3808 System.out.flush();
3809 output = new String(baos.toByteArray());
3810
3811 System.setOut(systemOut);
3812
3813 outputLines = GrouperClientUtils.splitTrim(output, "\n");
3814
3815 matcher = pattern.matcher(outputLines[0]);
3816
3817 assertTrue(outputLines[0], matcher.matches());
3818
3819 assertEquals("0", matcher.group(1));
3820 assertEquals("SUCCESS", matcher.group(2));
3821 assertEquals("test.subject.0", matcher.group(3));
3822 assertEquals("0", matcher.group(4));
3823 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3824 matcher.group(5))
3825 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3826
3827 matcher = pattern.matcher(outputLines[1]);
3828
3829 assertTrue(outputLines[1], matcher.matches());
3830
3831 assertEquals("0", matcher.group(1));
3832 assertEquals("SUCCESS", matcher.group(2));
3833 assertEquals("test.subject.0", matcher.group(3));
3834 assertEquals("1", matcher.group(4));
3835 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3836 matcher.group(5))
3837 || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3838
3839 matcher = pattern.matcher(outputLines[2]);
3840
3841 assertTrue(outputLines[2], matcher.matches());
3842
3843 assertEquals("1", matcher.group(1));
3844 assertEquals("SUCCESS", matcher.group(2));
3845 assertEquals("test.subject.1", matcher.group(3));
3846 assertEquals("0", matcher.group(4));
3847 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3848 matcher.group(5))
3849 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3850
3851 matcher = pattern.matcher(outputLines[3]);
3852
3853 assertTrue(outputLines[3], matcher.matches());
3854
3855 assertEquals("1", matcher.group(1));
3856 assertEquals("SUCCESS", matcher.group(2));
3857 assertEquals("test.subject.1", matcher.group(3));
3858 assertEquals("1", matcher.group(4));
3859 assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3860 matcher.group(5))
3861 || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3862
3863 assertTrue(GrouperClientWs.mostRecentRequest.contains("memberFilter")
3864 && GrouperClientWs.mostRecentRequest.contains("Immediate"));
3865
3866 } finally {
3867 if (subjectIdsFile.exists()) {
3868 subjectIdsFile.delete();
3869 }
3870 }
3871 } finally {
3872 System.setOut(systemOut);
3873 }
3874
3875 }
3876
3877
3878
3879
3880 public void testHasMemberNotFound() throws Exception {
3881
3882
3883 GrouperSession grouperSession = GrouperSession.startRootSession();
3884 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
3885 "aStem:aGroup", "aGroup", null, null, true);
3886
3887
3888 String wsUserLabel = GrouperClientUtils.propertiesValue(
3889 "grouperClient.webService.user.label", true);
3890 String wsUserString = GrouperClientUtils.propertiesValue(
3891 "grouperClient.webService." + wsUserLabel, true);
3892 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
3893
3894 group.grantPriv(wsUser, AccessPrivilege.READ, false);
3895 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3896
3897
3898 group.addMember(SubjectTestHelper.SUBJ0, false);
3899 group.addMember(SubjectTestHelper.SUBJ1, false);
3900
3901 PrintStream systemOut = System.out;
3902
3903 ByteArrayOutputStream baos = new ByteArrayOutputStream();
3904 System.setOut(new PrintStream(baos));
3905
3906 try {
3907
3908 GrouperClient
3909 .main(GrouperClientUtils
3910 .splitTrim(
3911 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=rwjdfskjlwirwklj",
3912 " "));
3913 System.out.flush();
3914 String output = new String(baos.toByteArray());
3915
3916 System.setOut(systemOut);
3917
3918 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
3919
3920 assertEquals(1, GrouperUtil.length(outputLines));
3921
3922 Pattern pattern = Pattern
3923 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.+): (false|true)$");
3924 Matcher matcher = pattern.matcher(outputLines[0]);
3925
3926 assertTrue(outputLines[0], matcher.matches());
3927
3928 assertEquals("0", matcher.group(1));
3929 assertEquals("IS_NOT_MEMBER", matcher.group(2));
3930 assertEquals("rwjdfskjlwirwklj", matcher.group(3));
3931 assertEquals("false", matcher.group(4));
3932
3933 } finally {
3934 System.setOut(systemOut);
3935 }
3936
3937 }
3938
3939
3940
3941
3942 public void testHasMember() throws Exception {
3943
3944
3945 GrouperSession grouperSession = GrouperSession.startRootSession();
3946 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
3947 "aStem:aGroup", "aGroup", null, null, true);
3948
3949
3950 String wsUserLabel = GrouperClientUtils.propertiesValue(
3951 "grouperClient.webService.user.label", true);
3952 String wsUserString = GrouperClientUtils.propertiesValue(
3953 "grouperClient.webService." + wsUserLabel, true);
3954 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
3955
3956 group.grantPriv(wsUser, AccessPrivilege.READ, false);
3957 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3958
3959
3960 group.addMember(SubjectTestHelper.SUBJ2, false);
3961 group.deleteMember(SubjectTestHelper.SUBJ2, false);
3962 Thread.sleep(100);
3963 Timestamp pointInTimeFrom = new Timestamp(new Date().getTime());
3964 Thread.sleep(100);
3965
3966 group.addMember(SubjectTestHelper.SUBJ3, false);
3967 group.deleteMember(SubjectTestHelper.SUBJ3, false);
3968
3969
3970 group.addMember(SubjectTestHelper.SUBJ0, false);
3971 group.addMember(SubjectTestHelper.SUBJ1, false);
3972
3973
3974 group.addMember(SubjectTestHelper.SUBJ4, false);
3975 group.deleteMember(SubjectTestHelper.SUBJ4, false);
3976 Thread.sleep(100);
3977 Timestamp pointInTimeTo = new Timestamp(new Date().getTime());
3978 Thread.sleep(100);
3979
3980 group.addMember(SubjectTestHelper.SUBJ5, false);
3981 group.deleteMember(SubjectTestHelper.SUBJ5, false);
3982 ChangeLogTempToEntity.convertRecords();
3983
3984 PrintStream systemOut = System.out;
3985
3986 ByteArrayOutputStream baos = new ByteArrayOutputStream();
3987 System.setOut(new PrintStream(baos));
3988
3989 try {
3990
3991 GrouperClient
3992 .main(GrouperClientUtils
3993 .splitTrim(
3994 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
3995 " "));
3996 System.out.flush();
3997 String output = new String(baos.toByteArray());
3998
3999 System.setOut(systemOut);
4000
4001 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
4002
4003 Pattern pattern = Pattern
4004 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.+): (false|true)$");
4005 Matcher matcher = pattern.matcher(outputLines[0]);
4006
4007 assertTrue(outputLines[0], matcher.matches());
4008
4009 assertEquals("0", matcher.group(1));
4010 assertEquals("IS_MEMBER", matcher.group(2));
4011 assertEquals("test.subject.0", matcher.group(3));
4012 assertEquals("true", matcher.group(4));
4013
4014 matcher = pattern.matcher(outputLines[1]);
4015
4016 assertTrue(outputLines[1], matcher.matches());
4017
4018 assertEquals("1", matcher.group(1));
4019 assertEquals("IS_MEMBER", matcher.group(2));
4020 assertEquals("test.subject.1", matcher.group(3));
4021 assertEquals("true", matcher.group(4));
4022
4023
4024
4025 baos = new ByteArrayOutputStream();
4026 System.setOut(new PrintStream(baos));
4027
4028
4029 try {
4030 GrouperClient
4031 .main(GrouperClientUtils
4032 .splitTrim(
4033 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=${index}",
4034 " "));
4035 } catch (Exception e) {
4036 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
4037 }
4038 System.out.flush();
4039
4040 System.setOut(systemOut);
4041
4042
4043
4044 baos = new ByteArrayOutputStream();
4045 System.setOut(new PrintStream(baos));
4046
4047
4048 GrouperClient
4049 .main(GrouperClientUtils
4050 .splitTrim(
4051 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${index}",
4052 " "));
4053
4054 System.out.flush();
4055
4056 output = new String(baos.toByteArray());
4057
4058 System.setOut(systemOut);
4059
4060 assertEquals("01", output);
4061
4062
4063
4064 baos = new ByteArrayOutputStream();
4065 System.setOut(new PrintStream(baos));
4066
4067 GrouperClient
4068 .main(GrouperClientUtils
4069 .splitTrim(
4070 "--operation=hasMemberWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0,id.test.subject.1 --fieldName=members",
4071 " "));
4072 System.out.flush();
4073 output = new String(baos.toByteArray());
4074
4075 System.setOut(systemOut);
4076
4077 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4078
4079 matcher = pattern.matcher(outputLines[0]);
4080
4081 assertTrue(outputLines[0], matcher.matches());
4082
4083 assertEquals("0", matcher.group(1));
4084 assertEquals("IS_MEMBER", matcher.group(2));
4085 assertEquals("test.subject.0", matcher.group(3));
4086 assertEquals("true", matcher.group(4));
4087
4088 matcher = pattern.matcher(outputLines[1]);
4089
4090 assertTrue(outputLines[1], matcher.matches());
4091
4092 assertEquals("1", matcher.group(1));
4093 assertEquals("IS_MEMBER", matcher.group(2));
4094 assertEquals("test.subject.1", matcher.group(3));
4095 assertEquals("true", matcher.group(4));
4096
4097 assertTrue(GrouperClientWs.mostRecentRequest,
4098 GrouperClientWs.mostRecentRequest.contains("fieldName")
4099 && GrouperClientWs.mostRecentRequest.contains("members")
4100 && !GrouperClientWs.mostRecentRequest.contains("txType"));
4101
4102
4103
4104 baos = new ByteArrayOutputStream();
4105 System.setOut(new PrintStream(baos));
4106
4107 GrouperClient
4108 .main(GrouperClientUtils
4109 .splitTrim(
4110 "--operation=hasMemberWs --groupUuid=" + group.getUuid() + " --pennKeys=id.test.subject.0,id.test.subject.1",
4111 " "));
4112 System.out.flush();
4113 output = new String(baos.toByteArray());
4114
4115 System.setOut(systemOut);
4116
4117 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4118
4119 matcher = pattern.matcher(outputLines[0]);
4120
4121 assertTrue(outputLines[0], matcher.matches());
4122
4123 assertEquals("0", matcher.group(1));
4124 assertEquals("IS_MEMBER", matcher.group(2));
4125 assertEquals("test.subject.0", matcher.group(3));
4126 assertEquals("true", matcher.group(4));
4127
4128 matcher = pattern.matcher(outputLines[1]);
4129
4130 assertTrue(outputLines[1], matcher.matches());
4131
4132 assertEquals("1", matcher.group(1));
4133 assertEquals("IS_MEMBER", matcher.group(2));
4134 assertEquals("test.subject.1", matcher.group(3));
4135 assertEquals("true", matcher.group(4));
4136
4137 assertTrue(GrouperClientWs.mostRecentRequest,
4138 GrouperClientWs.mostRecentRequest.contains("uuid"));
4139
4140
4141
4142
4143 baos = new ByteArrayOutputStream();
4144 System.setOut(new PrintStream(baos));
4145
4146 GrouperClient
4147 .main(GrouperClientUtils
4148 .splitTrim(
4149 "--operation=hasMemberWs --groupIdIndex=" + group.getIdIndex() + " --pennKeys=id.test.subject.0,id.test.subject.1",
4150 " "));
4151 System.out.flush();
4152 output = new String(baos.toByteArray());
4153
4154 System.setOut(systemOut);
4155
4156 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4157
4158 matcher = pattern.matcher(outputLines[0]);
4159
4160 assertTrue(outputLines[0], matcher.matches());
4161
4162 assertEquals("0", matcher.group(1));
4163 assertEquals("IS_MEMBER", matcher.group(2));
4164 assertEquals("test.subject.0", matcher.group(3));
4165 assertEquals("true", matcher.group(4));
4166
4167 matcher = pattern.matcher(outputLines[1]);
4168
4169 assertTrue(outputLines[1], matcher.matches());
4170
4171 assertEquals("1", matcher.group(1));
4172 assertEquals("IS_MEMBER", matcher.group(2));
4173 assertEquals("test.subject.1", matcher.group(3));
4174 assertEquals("true", matcher.group(4));
4175
4176 assertTrue(GrouperClientWs.mostRecentRequest,
4177 GrouperClientWs.mostRecentRequest.contains("idIndex"));
4178
4179
4180
4181 baos = new ByteArrayOutputStream();
4182 System.setOut(new PrintStream(baos));
4183
4184 GrouperClient
4185 .main(GrouperClientUtils
4186 .splitTrim(
4187 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
4188 " "));
4189 System.out.flush();
4190 output = new String(baos.toByteArray());
4191
4192 System.setOut(systemOut);
4193
4194 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4195
4196 matcher = pattern.matcher(outputLines[0]);
4197
4198 assertTrue(outputLines[0], matcher.matches());
4199
4200 assertEquals("0", matcher.group(1));
4201 assertEquals("IS_MEMBER", matcher.group(2));
4202 assertEquals("test.subject.0", matcher.group(3));
4203 assertEquals("true", matcher.group(4));
4204
4205 matcher = pattern.matcher(outputLines[1]);
4206
4207 assertTrue(outputLines[1], matcher.matches());
4208
4209 assertEquals("1", matcher.group(1));
4210 assertEquals("IS_MEMBER", matcher.group(2));
4211 assertEquals("test.subject.1", matcher.group(3));
4212 assertEquals("true", matcher.group(4));
4213
4214 assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
4215 && !GrouperClientWs.mostRecentRequest.contains("NONE")
4216 && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail")
4217 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
4218
4219
4220
4221 baos = new ByteArrayOutputStream();
4222 System.setOut(new PrintStream(baos));
4223
4224 GrouperClient
4225 .main(GrouperClientUtils
4226 .splitTrim(
4227 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsHasMemberResult.wsSubject.getAttributeValue(0)}$newline$",
4228 " "));
4229 System.out.flush();
4230 output = new String(baos.toByteArray());
4231
4232 System.setOut(systemOut);
4233
4234 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4235
4236 assertTrue(outputLines[0], outputLines[0]
4237 .contains("my name is test.subject.0"));
4238
4239 assertTrue(outputLines[1], outputLines[1]
4240 .contains("my name is test.subject.1"));
4241
4242 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
4243 assertTrue(GrouperClientWs.mostRecentResponse
4244 .contains("my name is test.subject.0"));
4245
4246
4247
4248 baos = new ByteArrayOutputStream();
4249 System.setOut(new PrintStream(baos));
4250
4251 GrouperClient
4252 .main(GrouperClientUtils
4253 .splitTrim(
4254 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
4255 " "));
4256 System.out.flush();
4257 output = new String(baos.toByteArray());
4258
4259 System.setOut(systemOut);
4260
4261 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4262
4263 matcher = pattern.matcher(outputLines[0]);
4264
4265 assertTrue(outputLines[0], matcher.matches());
4266
4267 assertEquals("0", matcher.group(1));
4268 assertEquals("IS_MEMBER", matcher.group(2));
4269 assertEquals("test.subject.0", matcher.group(3));
4270 assertEquals("true", matcher.group(4));
4271
4272 matcher = pattern.matcher(outputLines[1]);
4273
4274 assertTrue(outputLines[1], matcher.matches());
4275
4276 assertEquals("1", matcher.group(1));
4277 assertEquals("IS_MEMBER", matcher.group(2));
4278 assertEquals("test.subject.1", matcher.group(3));
4279 assertEquals("true", matcher.group(4));
4280
4281 assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
4282
4283
4284
4285 baos = new ByteArrayOutputStream();
4286 System.setOut(new PrintStream(baos));
4287
4288 String subjectIdsFileName = "subjectIdsFile_"
4289 + GrouperClientUtils.uniqueId() + ".txt";
4290 File subjectIdsFile = new File(subjectIdsFileName);
4291
4292 GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
4293 "test.subject.0\ntest.subject.1");
4294
4295 try {
4296 GrouperClient.main(GrouperClientUtils.splitTrim(
4297 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIdsFile="
4298 + subjectIdsFileName, " "));
4299 System.out.flush();
4300 output = new String(baos.toByteArray());
4301
4302 System.setOut(systemOut);
4303
4304 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4305
4306 matcher = pattern.matcher(outputLines[0]);
4307
4308 assertTrue(outputLines[0], matcher.matches());
4309
4310 assertEquals("0", matcher.group(1));
4311 assertEquals("IS_MEMBER", matcher.group(2));
4312 assertEquals("test.subject.0", matcher.group(3));
4313 assertEquals("true", matcher.group(4));
4314
4315 matcher = pattern.matcher(outputLines[1]);
4316
4317 assertTrue(outputLines[1], matcher.matches());
4318
4319 assertEquals("1", matcher.group(1));
4320 assertEquals("IS_MEMBER", matcher.group(2));
4321 assertEquals("test.subject.1", matcher.group(3));
4322 assertEquals("true", matcher.group(4));
4323
4324
4325
4326 baos = new ByteArrayOutputStream();
4327 System.setOut(new PrintStream(baos));
4328
4329 GrouperClient
4330 .main(GrouperClientUtils
4331 .splitTrim(
4332 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --paramName0=whatever --paramValue0=someValue",
4333 " "));
4334 System.out.flush();
4335 output = new String(baos.toByteArray());
4336
4337 System.setOut(systemOut);
4338
4339 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4340
4341 matcher = pattern.matcher(outputLines[0]);
4342
4343 assertTrue(outputLines[0], matcher.matches());
4344
4345 assertEquals("0", matcher.group(1));
4346 assertEquals("IS_MEMBER", matcher.group(2));
4347 assertEquals("test.subject.0", matcher.group(3));
4348
4349 matcher = pattern.matcher(outputLines[1]);
4350
4351 assertTrue(outputLines[1], matcher.matches());
4352
4353 assertEquals("1", matcher.group(1));
4354 assertEquals("IS_MEMBER", matcher.group(2));
4355 assertEquals("test.subject.1", matcher.group(3));
4356 assertEquals("true", matcher.group(4));
4357
4358 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
4359 && GrouperClientWs.mostRecentRequest.contains("someValue"));
4360
4361
4362
4363 baos = new ByteArrayOutputStream();
4364 System.setOut(new PrintStream(baos));
4365
4366 GrouperClient
4367 .main(GrouperClientUtils
4368 .splitTrim(
4369 "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --memberFilter=Immediate",
4370 " "));
4371 System.out.flush();
4372 output = new String(baos.toByteArray());
4373
4374 System.setOut(systemOut);
4375
4376 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4377
4378 matcher = pattern.matcher(outputLines[0]);
4379
4380 assertTrue(outputLines[0], matcher.matches());
4381
4382 assertEquals("0", matcher.group(1));
4383 assertEquals("IS_MEMBER", matcher.group(2));
4384 assertEquals("test.subject.0", matcher.group(3));
4385 assertEquals("true", matcher.group(4));
4386
4387 matcher = pattern.matcher(outputLines[1]);
4388
4389 assertTrue(outputLines[1], matcher.matches());
4390
4391 assertEquals("1", matcher.group(1));
4392 assertEquals("IS_MEMBER", matcher.group(2));
4393 assertEquals("test.subject.1", matcher.group(3));
4394 assertEquals("true", matcher.group(4));
4395
4396 assertTrue(GrouperClientWs.mostRecentRequest.contains("memberFilter")
4397 && GrouperClientWs.mostRecentRequest.contains("Immediate"));
4398
4399
4400
4401
4402 baos = new ByteArrayOutputStream();
4403 System.setOut(new PrintStream(baos));
4404
4405 ArrayList<String> args = new ArrayList<String>();
4406 args.add("--operation=hasMemberWs");
4407 args.add("--groupName=aStem:aGroup");
4408 args.add("--subjectIds=test.subject.0,test.subject.1,test.subject.2,test.subject.3,test.subject.4,test.subject.5");
4409 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTimeFrom));
4410 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTimeTo));
4411 GrouperClient.main(args.toArray(new String[0]));
4412
4413 System.out.flush();
4414 output = new String(baos.toByteArray());
4415
4416 System.setOut(systemOut);
4417
4418 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4419
4420 matcher = pattern.matcher(outputLines[0]);
4421 assertTrue(outputLines[0], matcher.matches());
4422 assertEquals("0", matcher.group(1));
4423 assertEquals("IS_MEMBER", matcher.group(2));
4424 assertEquals("test.subject.0", matcher.group(3));
4425 assertEquals("true", matcher.group(4));
4426
4427 matcher = pattern.matcher(outputLines[1]);
4428 assertTrue(outputLines[1], matcher.matches());
4429 assertEquals("1", matcher.group(1));
4430 assertEquals("IS_MEMBER", matcher.group(2));
4431 assertEquals("test.subject.1", matcher.group(3));
4432 assertEquals("true", matcher.group(4));
4433
4434 matcher = pattern.matcher(outputLines[2]);
4435 assertTrue(outputLines[2], matcher.matches());
4436 assertEquals("2", matcher.group(1));
4437 assertEquals("IS_NOT_MEMBER", matcher.group(2));
4438 assertEquals("test.subject.2", matcher.group(3));
4439 assertEquals("false", matcher.group(4));
4440
4441 matcher = pattern.matcher(outputLines[3]);
4442 assertTrue(outputLines[3], matcher.matches());
4443 assertEquals("3", matcher.group(1));
4444 assertEquals("IS_MEMBER", matcher.group(2));
4445 assertEquals("test.subject.3", matcher.group(3));
4446 assertEquals("true", matcher.group(4));
4447
4448 matcher = pattern.matcher(outputLines[4]);
4449 assertTrue(outputLines[4], matcher.matches());
4450 assertEquals("4", matcher.group(1));
4451 assertEquals("IS_MEMBER", matcher.group(2));
4452 assertEquals("test.subject.4", matcher.group(3));
4453 assertEquals("true", matcher.group(4));
4454
4455 matcher = pattern.matcher(outputLines[5]);
4456 assertTrue(outputLines[5], matcher.matches());
4457 assertEquals("5", matcher.group(1));
4458 assertEquals("IS_NOT_MEMBER", matcher.group(2));
4459 assertEquals("test.subject.5", matcher.group(3));
4460 assertEquals("false", matcher.group(4));
4461
4462 } finally {
4463 if (subjectIdsFile.exists()) {
4464 subjectIdsFile.delete();
4465 }
4466 }
4467 } finally {
4468 System.setOut(systemOut);
4469 }
4470
4471 }
4472
4473
4474
4475
4476 public void testDeleteMember() throws Exception {
4477
4478
4479 GrouperSession grouperSession = GrouperSession.startRootSession();
4480 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
4481 "aStem:aGroup", "aGroup", null, null, true);
4482
4483
4484 String wsUserLabel = GrouperClientUtils.propertiesValue(
4485 "grouperClient.webService.user.label", true);
4486 String wsUserString = GrouperClientUtils.propertiesValue(
4487 "grouperClient.webService." + wsUserLabel, true);
4488 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
4489
4490 group.grantPriv(wsUser, AccessPrivilege.READ, false);
4491 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
4492 group.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
4493
4494
4495 group.addMember(SubjectTestHelper.SUBJ0, false);
4496 group.addMember(SubjectTestHelper.SUBJ1, false);
4497
4498 PrintStream systemOut = System.out;
4499
4500 ByteArrayOutputStream baos = new ByteArrayOutputStream();
4501 System.setOut(new PrintStream(baos));
4502
4503 try {
4504
4505 GrouperClient.main(GrouperClientUtils.splitTrim(
4506 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
4507 " "));
4508 System.out.flush();
4509 String output = new String(baos.toByteArray());
4510
4511 System.setOut(systemOut);
4512
4513 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
4514
4515 Pattern pattern = Pattern
4516 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
4517 Matcher matcher = pattern.matcher(outputLines[0]);
4518
4519 assertTrue(outputLines[0], matcher.matches());
4520
4521 assertEquals("0", matcher.group(1));
4522 assertEquals("SUCCESS", matcher.group(2));
4523 assertEquals("test.subject.0", matcher.group(3));
4524
4525 matcher = pattern.matcher(outputLines[1]);
4526
4527 assertTrue(outputLines[1], matcher.matches());
4528
4529 assertEquals("1", matcher.group(1));
4530 assertEquals("SUCCESS", matcher.group(2));
4531 assertEquals("test.subject.1", matcher.group(3));
4532
4533
4534
4535 baos = new ByteArrayOutputStream();
4536 System.setOut(new PrintStream(baos));
4537
4538 GrouperClient.main(GrouperClientUtils
4539 .splitTrim(
4540 "--operation=deleteMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0,test.subject.1",
4541 " "));
4542 System.out.flush();
4543 output = new String(baos.toByteArray());
4544
4545 System.setOut(systemOut);
4546
4547 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4548
4549 matcher = pattern.matcher(outputLines[0]);
4550
4551 assertTrue(outputLines[0], matcher.matches());
4552
4553 assertEquals(outputLines[0], "0", matcher.group(1));
4554 assertEquals(outputLines[0], "SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4555 assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
4556
4557 matcher = pattern.matcher(outputLines[1]);
4558
4559 assertTrue(outputLines[1], matcher.matches());
4560
4561 assertEquals("1", matcher.group(1));
4562 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4563 assertEquals("test.subject.1", matcher.group(3));
4564
4565
4566
4567
4568 baos = new ByteArrayOutputStream();
4569 System.setOut(new PrintStream(baos));
4570
4571 GrouperClient.main(GrouperClientUtils
4572 .splitTrim(
4573 "--operation=deleteMemberWs --groupIdIndex=" + group.getIdIndex() + " --pennIds=test.subject.0,test.subject.1",
4574 " "));
4575 System.out.flush();
4576 output = new String(baos.toByteArray());
4577
4578 System.setOut(systemOut);
4579
4580 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4581
4582 matcher = pattern.matcher(outputLines[0]);
4583
4584 assertTrue(outputLines[0], matcher.matches());
4585
4586 assertEquals(outputLines[0], "0", matcher.group(1));
4587 assertEquals(outputLines[0], "SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4588 assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
4589
4590 matcher = pattern.matcher(outputLines[1]);
4591
4592 assertTrue(outputLines[1], matcher.matches());
4593
4594 assertEquals("1", matcher.group(1));
4595 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4596 assertEquals("test.subject.1", matcher.group(3));
4597
4598
4599
4600 baos = new ByteArrayOutputStream();
4601 System.setOut(new PrintStream(baos));
4602
4603 GrouperClient.main(GrouperClientUtils
4604 .splitTrim(
4605 "--operation=deleteMemberWs --groupUuid=" + group.getUuid() + " --pennIds=test.subject.0,test.subject.1",
4606 " "));
4607 System.out.flush();
4608 output = new String(baos.toByteArray());
4609
4610 System.setOut(systemOut);
4611
4612 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4613
4614 matcher = pattern.matcher(outputLines[0]);
4615
4616 assertTrue(outputLines[0], matcher.matches());
4617
4618 assertEquals(outputLines[0], "0", matcher.group(1));
4619 assertEquals(outputLines[0], "SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4620 assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
4621
4622 matcher = pattern.matcher(outputLines[1]);
4623
4624 assertTrue(outputLines[1], matcher.matches());
4625
4626 assertEquals("1", matcher.group(1));
4627 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4628 assertEquals("test.subject.1", matcher.group(3));
4629
4630
4631
4632 baos = new ByteArrayOutputStream();
4633 System.setOut(new PrintStream(baos));
4634
4635
4636 try {
4637 GrouperClient
4638 .main(GrouperClientUtils
4639 .splitTrim(
4640 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=${index}",
4641 " "));
4642 } catch (Exception e) {
4643 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
4644 }
4645 System.out.flush();
4646
4647 System.setOut(systemOut);
4648
4649
4650
4651 baos = new ByteArrayOutputStream();
4652 System.setOut(new PrintStream(baos));
4653
4654
4655 GrouperClient
4656 .main(GrouperClientUtils
4657 .splitTrim(
4658 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${index}",
4659 " "));
4660
4661 System.out.flush();
4662
4663 output = new String(baos.toByteArray());
4664
4665 System.setOut(systemOut);
4666
4667 assertEquals("01", output);
4668
4669
4670
4671 baos = new ByteArrayOutputStream();
4672 System.setOut(new PrintStream(baos));
4673
4674 GrouperClient
4675 .main(GrouperClientUtils
4676 .splitTrim(
4677 "--operation=deleteMemberWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0,id.test.subject.1 --fieldName=members",
4678 " "));
4679 System.out.flush();
4680 output = new String(baos.toByteArray());
4681
4682 System.setOut(systemOut);
4683
4684 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4685
4686 matcher = pattern.matcher(outputLines[0]);
4687
4688 assertTrue(outputLines[0], matcher.matches());
4689
4690 assertEquals("0", matcher.group(1));
4691 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4692 assertEquals("test.subject.0", matcher.group(3));
4693
4694 matcher = pattern.matcher(outputLines[1]);
4695
4696 assertTrue(outputLines[1], matcher.matches());
4697
4698 assertEquals("1", matcher.group(1));
4699 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4700 assertEquals("test.subject.1", matcher.group(3));
4701
4702 assertTrue(GrouperClientWs.mostRecentRequest,
4703 GrouperClientWs.mostRecentRequest.contains("fieldName")
4704 && GrouperClientWs.mostRecentRequest.contains("members")
4705 && !GrouperClientWs.mostRecentRequest.contains("txType"));
4706
4707
4708
4709 baos = new ByteArrayOutputStream();
4710 System.setOut(new PrintStream(baos));
4711
4712 GrouperClient
4713 .main(GrouperClientUtils
4714 .splitTrim(
4715 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --txType=NONE",
4716 " "));
4717 System.out.flush();
4718 output = new String(baos.toByteArray());
4719
4720 System.setOut(systemOut);
4721
4722 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4723
4724 matcher = pattern.matcher(outputLines[0]);
4725
4726 assertTrue(outputLines[0], matcher.matches());
4727
4728 assertEquals("0", matcher.group(1));
4729 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4730 assertEquals("test.subject.0", matcher.group(3));
4731
4732 matcher = pattern.matcher(outputLines[1]);
4733
4734 assertTrue(outputLines[1], matcher.matches());
4735
4736 assertEquals("1", matcher.group(1));
4737 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4738 assertEquals("test.subject.1", matcher.group(3));
4739
4740 assertTrue(GrouperClientWs.mostRecentRequest,
4741 !GrouperClientWs.mostRecentRequest.contains("fieldName")
4742 && !GrouperClientWs.mostRecentRequest.contains("members")
4743 && GrouperClientWs.mostRecentRequest.contains("txType")
4744 && GrouperClientWs.mostRecentRequest.contains("NONE")
4745 && !GrouperClientWs.mostRecentRequest
4746 .contains("includeGroupDetail")
4747 && !GrouperClientWs.mostRecentRequest
4748 .contains("includeSubjectDetail")
4749 && !GrouperClientWs.mostRecentRequest
4750 .contains("includeGroupDetail")
4751 && !GrouperClientWs.mostRecentRequest
4752 .contains("includeSubjectDetail"));
4753
4754
4755
4756 baos = new ByteArrayOutputStream();
4757 System.setOut(new PrintStream(baos));
4758
4759 GrouperClient
4760 .main(GrouperClientUtils
4761 .splitTrim(
4762 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
4763 " "));
4764 System.out.flush();
4765 output = new String(baos.toByteArray());
4766
4767 System.setOut(systemOut);
4768
4769 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4770
4771 matcher = pattern.matcher(outputLines[0]);
4772
4773 assertTrue(outputLines[0], matcher.matches());
4774
4775 assertEquals("0", matcher.group(1));
4776 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4777 assertEquals("test.subject.0", matcher.group(3));
4778
4779 matcher = pattern.matcher(outputLines[1]);
4780
4781 assertTrue(outputLines[1], matcher.matches());
4782
4783 assertEquals("1", matcher.group(1));
4784 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4785 assertEquals("test.subject.1", matcher.group(3));
4786
4787 assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
4788 && !GrouperClientWs.mostRecentRequest.contains("NONE")
4789 && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail")
4790 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
4791
4792
4793
4794 baos = new ByteArrayOutputStream();
4795 System.setOut(new PrintStream(baos));
4796
4797 GrouperClient
4798 .main(GrouperClientUtils
4799 .splitTrim(
4800 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsDeleteMemberResult.wsSubject.getAttributeValue(0)}$newline$",
4801 " "));
4802 System.out.flush();
4803 output = new String(baos.toByteArray());
4804
4805 System.setOut(systemOut);
4806
4807 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4808
4809 assertTrue(outputLines[0], outputLines[0]
4810 .contains("my name is test.subject.0"));
4811
4812 assertTrue(outputLines[1], outputLines[1]
4813 .contains("my name is test.subject.1"));
4814
4815 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
4816 assertTrue(GrouperClientWs.mostRecentResponse
4817 .contains("my name is test.subject.0"));
4818
4819
4820
4821 baos = new ByteArrayOutputStream();
4822 System.setOut(new PrintStream(baos));
4823
4824 GrouperClient
4825 .main(GrouperClientUtils
4826 .splitTrim(
4827 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
4828 " "));
4829 System.out.flush();
4830 output = new String(baos.toByteArray());
4831
4832 System.setOut(systemOut);
4833
4834 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4835
4836 matcher = pattern.matcher(outputLines[0]);
4837
4838 assertTrue(outputLines[0], matcher.matches());
4839
4840 assertEquals("0", matcher.group(1));
4841 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4842 assertEquals("test.subject.0", matcher.group(3));
4843
4844 matcher = pattern.matcher(outputLines[1]);
4845
4846 assertTrue(outputLines[1], matcher.matches());
4847
4848 assertEquals("1", matcher.group(1));
4849 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4850 assertEquals("test.subject.1", matcher.group(3));
4851
4852 assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
4853
4854
4855
4856 baos = new ByteArrayOutputStream();
4857 System.setOut(new PrintStream(baos));
4858
4859 String subjectIdsFileName = "subjectIdsFile_"
4860 + GrouperClientUtils.uniqueId() + ".txt";
4861 File subjectIdsFile = new File(subjectIdsFileName);
4862
4863 GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
4864 "test.subject.0\ntest.subject.1");
4865
4866 try {
4867 GrouperClient.main(GrouperClientUtils.splitTrim(
4868 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIdsFile="
4869 + subjectIdsFileName, " "));
4870 System.out.flush();
4871 output = new String(baos.toByteArray());
4872
4873 System.setOut(systemOut);
4874
4875 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4876
4877 matcher = pattern.matcher(outputLines[0]);
4878
4879 assertTrue(outputLines[0], matcher.matches());
4880
4881 assertEquals("0", matcher.group(1));
4882 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4883 assertEquals("test.subject.0", matcher.group(3));
4884
4885 matcher = pattern.matcher(outputLines[1]);
4886
4887 assertTrue(outputLines[1], matcher.matches());
4888
4889 assertEquals("1", matcher.group(1));
4890 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4891 assertEquals("test.subject.1", matcher.group(3));
4892
4893
4894
4895 baos = new ByteArrayOutputStream();
4896 System.setOut(new PrintStream(baos));
4897
4898 GrouperClient
4899 .main(GrouperClientUtils
4900 .splitTrim(
4901 "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --paramName0=whatever --paramValue0=someValue",
4902 " "));
4903 System.out.flush();
4904 output = new String(baos.toByteArray());
4905
4906 System.setOut(systemOut);
4907
4908 outputLines = GrouperClientUtils.splitTrim(output, "\n");
4909
4910 matcher = pattern.matcher(outputLines[0]);
4911
4912 assertTrue(outputLines[0], matcher.matches());
4913
4914 assertEquals("0", matcher.group(1));
4915 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4916 assertEquals("test.subject.0", matcher.group(3));
4917
4918 matcher = pattern.matcher(outputLines[1]);
4919
4920 assertTrue(outputLines[1], matcher.matches());
4921
4922 assertEquals("1", matcher.group(1));
4923 assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4924 assertEquals("test.subject.1", matcher.group(3));
4925
4926 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
4927 && GrouperClientWs.mostRecentRequest.contains("someValue"));
4928
4929 } finally {
4930 if (subjectIdsFile.exists()) {
4931 subjectIdsFile.delete();
4932 }
4933 }
4934 } finally {
4935 System.setOut(systemOut);
4936 }
4937
4938 }
4939
4940
4941
4942
4943 public void testMemberChangeSubject() throws Exception {
4944
4945 PrintStream systemOut = System.out;
4946
4947 ByteArrayOutputStream baos = new ByteArrayOutputStream();
4948 System.setOut(new PrintStream(baos));
4949
4950 try {
4951
4952 GrouperClient
4953 .main(GrouperClientUtils
4954 .splitTrim(
4955 "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem",
4956 " "));
4957 System.out.flush();
4958 String output = new String(baos.toByteArray());
4959
4960 System.setOut(systemOut);
4961
4962 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
4963
4964 Pattern pattern = Pattern
4965 .compile("^Success: T: code: ([A-Z_]+): oldSubject: (.+), newSubject: (.+)$");
4966 Matcher matcher = pattern.matcher(outputLines[0]);
4967
4968 assertEquals(1, outputLines.length);
4969 assertTrue(outputLines[0], matcher.matches());
4970
4971 assertEquals("SUCCESS", matcher.group(1));
4972 assertEquals("test.subject.0", matcher.group(2));
4973 assertEquals("test.subject.1", matcher.group(3));
4974
4975
4976
4977 baos = new ByteArrayOutputStream();
4978 System.setOut(new PrintStream(baos));
4979
4980
4981 try {
4982 GrouperClient
4983 .main(GrouperClientUtils
4984 .splitTrim(
4985 "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem",
4986 " "));
4987 fail("Should not get here");
4988 } catch (GcWebServiceError gwse) {
4989 WsMemberChangeSubjectResults wsMemberChangeSubjectResults = (WsMemberChangeSubjectResults) gwse
4990 .getContainerResponseObject();
4991 assertEquals("PROBLEM_WITH_CHANGE", wsMemberChangeSubjectResults
4992 .getResultMetadata().getResultCode());
4993 }
4994
4995
4996
4997 baos = new ByteArrayOutputStream();
4998 System.setOut(new PrintStream(baos));
4999
5000
5001 try {
5002 GrouperClient
5003 .main(GrouperClientUtils
5004 .splitTrim(
5005 "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem --ousdfsdfate=${index}",
5006 " "));
5007 } catch (Exception e) {
5008 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
5009 }
5010 System.out.flush();
5011
5012 System.setOut(systemOut);
5013
5014
5015
5016 baos = new ByteArrayOutputStream();
5017 System.setOut(new PrintStream(baos));
5018
5019
5020 GrouperClient
5021 .main(GrouperClientUtils
5022 .splitTrim(
5023 "--operation=memberChangeSubjectWs --oldPennKey=id.test.subject.1 --newPennKey=id.test.subject.0 --actAsPennId=GrouperSystem --outputTemplate=${index}",
5024 " "));
5025
5026 System.out.flush();
5027
5028 output = new String(baos.toByteArray());
5029
5030 System.setOut(systemOut);
5031
5032 assertEquals("0", output);
5033
5034
5035
5036 baos = new ByteArrayOutputStream();
5037 System.setOut(new PrintStream(baos));
5038
5039 GrouperClient
5040 .main(GrouperClientUtils
5041 .splitTrim(
5042 "--operation=memberChangeSubjectWs --oldSubjectIdentifier=id.test.subject.0 --newSubjectIdentifier=id.test.subject.1 --actAsSubjectId=GrouperSystem --deleteOldMember=false",
5043 " "));
5044 System.out.flush();
5045 output = new String(baos.toByteArray());
5046
5047 System.setOut(systemOut);
5048
5049 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5050
5051 matcher = pattern.matcher(outputLines[0]);
5052
5053 assertEquals(1, outputLines.length);
5054 assertTrue(outputLines[0], matcher.matches());
5055
5056 assertEquals("SUCCESS", matcher.group(1));
5057 assertEquals("test.subject.0", matcher.group(2));
5058 assertEquals("test.subject.1", matcher.group(3));
5059
5060 assertTrue(GrouperClientWs.mostRecentRequest,
5061 GrouperClientWs.mostRecentRequest.contains("deleteOldMember"));
5062
5063
5064
5065 baos = new ByteArrayOutputStream();
5066 System.setOut(new PrintStream(baos));
5067
5068 GrouperClient
5069 .main(GrouperClientUtils
5070 .splitTrim(
5071 "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.1 --newSubjectId=test.subject.0 --actAsSubjectId=GrouperSystem --includeSubjectDetail=true",
5072 " "));
5073 System.out.flush();
5074 output = new String(baos.toByteArray());
5075
5076 System.setOut(systemOut);
5077
5078 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5079
5080 matcher = pattern.matcher(outputLines[0]);
5081
5082 assertEquals(1, outputLines.length);
5083 assertTrue(outputLines[0], matcher.matches());
5084
5085 assertEquals("SUCCESS", matcher.group(1));
5086 assertEquals("test.subject.1", matcher.group(2));
5087 assertEquals("test.subject.0", matcher.group(3));
5088
5089 assertTrue(GrouperClientWs.mostRecentRequest
5090 .contains("includeSubjectDetail"));
5091
5092
5093
5094 baos = new ByteArrayOutputStream();
5095 System.setOut(new PrintStream(baos));
5096
5097 GrouperClient
5098 .main(GrouperClientUtils
5099 .splitTrim(
5100 "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsSubjectOld.getAttributeValue(0)}$newline$",
5101 " "));
5102 System.out.flush();
5103 output = new String(baos.toByteArray());
5104
5105 System.setOut(systemOut);
5106
5107 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5108
5109 assertTrue(outputLines[0], outputLines[0]
5110 .contains("my name is test.subject.0"));
5111
5112 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
5113 assertTrue(GrouperClientWs.mostRecentResponse
5114 .contains("my name is test.subject.0"));
5115
5116
5117
5118 baos = new ByteArrayOutputStream();
5119 System.setOut(new PrintStream(baos));
5120
5121 GrouperClient
5122 .main(GrouperClientUtils
5123 .splitTrim(
5124 "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.1 --newSubjectId=test.subject.0 --actAsSubjectId=GrouperSystem --paramName0=whatever --paramValue0=someValue",
5125 " "));
5126 System.out.flush();
5127 output = new String(baos.toByteArray());
5128
5129 System.setOut(systemOut);
5130
5131 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5132
5133 matcher = pattern.matcher(outputLines[0]);
5134
5135 assertEquals(1, outputLines.length);
5136 assertTrue(outputLines[0], matcher.matches());
5137
5138 assertEquals("SUCCESS", matcher.group(1));
5139 assertEquals("test.subject.1", matcher.group(2));
5140 assertEquals("test.subject.0", matcher.group(3));
5141
5142 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
5143 && GrouperClientWs.mostRecentRequest.contains("someValue"));
5144
5145 } finally {
5146 System.setOut(systemOut);
5147 }
5148
5149 }
5150
5151
5152
5153
5154 public void testSendFile() throws Exception {
5155
5156 PrintStream systemOut = System.out;
5157
5158 ByteArrayOutputStream baos = new ByteArrayOutputStream();
5159 System.setOut(new PrintStream(baos));
5160
5161 File file = new File("testSendFile.txt");
5162 file.deleteOnExit();
5163
5164 try {
5165 String contents = "<WsRestAddMemberRequest>"
5166 + "<wsGroupLookup><groupName>aStem:aGroup</groupName></wsGroupLookup>"
5167 + "<subjectLookups><WsSubjectLookup>"
5168 + "<subjectId>test.subject.0</subjectId></WsSubjectLookup>"
5169 + "</subjectLookups></WsRestAddMemberRequest>";
5170 GrouperClientUtils.saveStringIntoFile(file, contents);
5171
5172 GrouperClient
5173 .main(GrouperClientUtils
5174 .splitTrim(
5175 "--operation=sendFile --fileName=testSendFile.txt --urlSuffix=groups/aStem:aGroup/members",
5176 " "));
5177 System.out.flush();
5178 String output = new String(baos.toByteArray());
5179
5180 System.setOut(systemOut);
5181
5182 assertTrue(output.contains("<resultCode>SUCCESS</resultCode>")
5183 && output.contains(" "));
5184
5185
5186
5187 baos = new ByteArrayOutputStream();
5188 System.setOut(new PrintStream(baos));
5189
5190 GrouperClient
5191 .main(GrouperClientUtils
5192 .splitTrim(
5193 "--operation=sendFile --fileContents="
5194 + contents
5195 + " --urlSuffix=groups/aStem:aGroup/members --indentOutput=false",
5196 " "));
5197
5198 System.out.flush();
5199 output = new String(baos.toByteArray());
5200
5201 System.setOut(systemOut);
5202
5203 assertTrue(output.contains("<resultCode>SUCCESS</resultCode>")
5204 && !output.contains(" "));
5205
5206 } finally {
5207 System.setOut(systemOut);
5208 file.delete();
5209 }
5210
5211 }
5212
5213
5214
5215
5216 public void testFindGroups() throws Exception {
5217
5218
5219 GrouperSession grouperSession = GrouperSession.startRootSession();
5220 Group group = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
5221
5222 GroupType groupType = GroupTypeFinder.find("aType", true);
5223 group.addType(groupType, false);
5224 group.setAttribute("attr_1", "something");
5225 group.store();
5226
5227 PrintStream systemOut = System.out;
5228
5229 ByteArrayOutputStream baos = new ByteArrayOutputStream();
5230 System.setOut(new PrintStream(baos));
5231
5232 try {
5233
5234 GrouperClient
5235 .main(GrouperClientUtils
5236 .splitTrim(
5237 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup",
5238 " "));
5239 System.out.flush();
5240 String output = new String(baos.toByteArray());
5241
5242 System.setOut(systemOut);
5243
5244 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
5245
5246 Pattern pattern = Pattern
5247 .compile("^Index (\\d+): name: (.+), displayName: (.+)$");
5248 Matcher matcher = pattern.matcher(outputLines[0]);
5249
5250 assertEquals(output, 1, outputLines.length);
5251 assertTrue(outputLines[0], matcher.matches());
5252
5253 assertEquals(output, "0", matcher.group(1));
5254 assertEquals(output, "aStem:aGroup", matcher.group(2));
5255 assertEquals(output, "aStem:aGroup", matcher.group(3));
5256
5257
5258
5259
5260 baos = new ByteArrayOutputStream();
5261 System.setOut(new PrintStream(baos));
5262
5263 GrouperClient
5264 .main(GrouperClientUtils
5265 .splitTrim(
5266 "--operation=findGroupsWs --queryFilterType=FIND_BY_STEM_NAME --stemName=a:b:doesntExist",
5267 " "));
5268 System.out.flush();
5269 output = new String(baos.toByteArray());
5270
5271 System.setOut(systemOut);
5272
5273 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5274
5275 assertEquals(output, 0, GrouperUtil.length(outputLines));
5276
5277 System.out.flush();
5278
5279 System.setOut(systemOut);
5280
5281
5282
5283
5284 baos = new ByteArrayOutputStream();
5285 System.setOut(new PrintStream(baos));
5286
5287
5288 try {
5289 GrouperClient
5290 .main(GrouperClientUtils
5291 .splitTrim(
5292 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --ousdfsdfate=${index}",
5293 " "));
5294 } catch (Exception e) {
5295 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
5296 }
5297 System.out.flush();
5298
5299 System.setOut(systemOut);
5300
5301
5302
5303 baos = new ByteArrayOutputStream();
5304 System.setOut(new PrintStream(baos));
5305
5306
5307 GrouperClient
5308 .main(GrouperClientUtils
5309 .splitTrim(
5310 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --outputTemplate=${index}",
5311 " "));
5312
5313 System.out.flush();
5314
5315 output = new String(baos.toByteArray());
5316
5317 System.setOut(systemOut);
5318
5319 assertEquals("0", output);
5320
5321
5322
5323 baos = new ByteArrayOutputStream();
5324 System.setOut(new PrintStream(baos));
5325
5326 GrouperClient
5327 .main(GrouperClientUtils
5328 .splitTrim(
5329 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --includeGroupDetail=true",
5330 " "));
5331 System.out.flush();
5332 output = new String(baos.toByteArray());
5333
5334 System.setOut(systemOut);
5335
5336 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5337
5338 matcher = pattern.matcher(outputLines[0]);
5339
5340 assertEquals(output, 1, outputLines.length);
5341 assertTrue(outputLines[0], matcher.matches());
5342
5343 assertEquals(output, "0", matcher.group(1));
5344 assertEquals(output, "aStem:aGroup", matcher.group(2));
5345 assertEquals(output, "aStem:aGroup", matcher.group(3));
5346
5347 assertTrue(GrouperClientWs.mostRecentRequest
5348 .contains("includeGroupDetail"));
5349
5350
5351
5352 baos = new ByteArrayOutputStream();
5353 System.setOut(new PrintStream(baos));
5354
5355 GrouperClient
5356 .main(GrouperClientUtils
5357 .splitTrim(
5358 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --paramName0=whatever --paramValue0=someValue",
5359 " "));
5360 System.out.flush();
5361 output = new String(baos.toByteArray());
5362
5363 System.setOut(systemOut);
5364
5365 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5366
5367 matcher = pattern.matcher(outputLines[0]);
5368
5369 assertEquals(output, 1, outputLines.length);
5370 assertTrue(outputLines[0], matcher.matches());
5371
5372 assertEquals(output, "0", matcher.group(1));
5373 assertEquals(output, "aStem:aGroup", matcher.group(2));
5374 assertEquals(output, "aStem:aGroup", matcher.group(3));
5375
5376 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
5377 && GrouperClientWs.mostRecentRequest.contains("someValue"));
5378
5379
5380
5381 baos = new ByteArrayOutputStream();
5382 System.setOut(new PrintStream(baos));
5383
5384 GrouperClient
5385 .main(GrouperClientUtils
5386 .splitTrim(
5387 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_UUID --groupUuid=abc",
5388 " "));
5389 System.out.flush();
5390 output = new String(baos.toByteArray());
5391
5392 System.setOut(systemOut);
5393
5394 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5395
5396 assertTrue(output, GrouperClientUtils.isBlank(output));
5397
5398 assertTrue(GrouperClientWs.mostRecentRequest.contains("groupUuid")
5399 && GrouperClientWs.mostRecentRequest.contains("abc"));
5400
5401
5402
5403 baos = new ByteArrayOutputStream();
5404 System.setOut(new PrintStream(baos));
5405
5406 GrouperClient
5407 .main(GrouperClientUtils
5408 .splitTrim(
5409 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --stemName=aStem",
5410 " "));
5411 System.out.flush();
5412 output = new String(baos.toByteArray());
5413
5414 System.setOut(systemOut);
5415
5416 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5417
5418 matcher = pattern.matcher(outputLines[0]);
5419
5420 assertEquals(output, 1, outputLines.length);
5421 assertTrue(outputLines[0], matcher.matches());
5422
5423 assertEquals(output, "0", matcher.group(1));
5424 assertEquals(output, "aStem:aGroup", matcher.group(2));
5425 assertEquals(output, "aStem:aGroup", matcher.group(3));
5426
5427 assertTrue(GrouperClientWs.mostRecentRequest.contains("stemName")
5428 && GrouperClientWs.mostRecentRequest.contains(">aStem<"));
5429
5430
5431
5432 baos = new ByteArrayOutputStream();
5433 System.setOut(new PrintStream(baos));
5434
5435 GrouperClient
5436 .main(GrouperClientUtils
5437 .splitTrim(
5438 "--operation=findGroupsWs --queryFilterType=FIND_BY_TYPE --groupTypeName=aType",
5439 " "));
5440 System.out.flush();
5441 output = new String(baos.toByteArray());
5442
5443 System.setOut(systemOut);
5444
5445 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5446
5447 matcher = pattern.matcher(outputLines[0]);
5448
5449 assertEquals(output, 1, outputLines.length);
5450 assertTrue(outputLines[0], matcher.matches());
5451
5452 assertEquals(output, "0", matcher.group(1));
5453 assertEquals(output, "aStem:aGroup", matcher.group(2));
5454 assertEquals(output, "aStem:aGroup", matcher.group(3));
5455
5456 assertTrue(GrouperClientWs.mostRecentRequest.contains("FIND_BY_TYPE")
5457 && GrouperClientWs.mostRecentRequest.contains("groupTypeName")
5458 && GrouperClientWs.mostRecentRequest.contains("aType"));
5459
5460
5461
5462 baos = new ByteArrayOutputStream();
5463 System.setOut(new PrintStream(baos));
5464
5465 GrouperClient
5466 .main(GrouperClientUtils
5467 .splitTrim(
5468 "--operation=findGroupsWs --queryFilterType=FIND_BY_EXACT_ATTRIBUTE --groupAttributeName=attr_1 --groupAttributeValue=something",
5469 " "));
5470 System.out.flush();
5471 output = new String(baos.toByteArray());
5472
5473 System.setOut(systemOut);
5474
5475 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5476
5477 matcher = pattern.matcher(outputLines[0]);
5478
5479 assertEquals(output, 1, outputLines.length);
5480 assertTrue(outputLines[0], matcher.matches());
5481
5482 assertEquals(output, "0", matcher.group(1));
5483 assertEquals(output, "aStem:aGroup", matcher.group(2));
5484 assertEquals(output, "aStem:aGroup", matcher.group(3));
5485
5486 assertTrue(GrouperClientWs.mostRecentRequest
5487 .contains("FIND_BY_EXACT_ATTRIBUTE")
5488 && GrouperClientWs.mostRecentRequest.contains("groupAttributeName")
5489 && GrouperClientWs.mostRecentRequest.contains("attr_1"));
5490
5491
5492
5493 baos = new ByteArrayOutputStream();
5494 System.setOut(new PrintStream(baos));
5495
5496 GrouperClient
5497 .main(GrouperClientUtils
5498 .splitTrim(
5499 "--operation=findGroupsWs --queryFilterType=OR --queryFilterType0=OR --queryFilterType00=FIND_BY_GROUP_NAME_APPROXIMATE --groupName00=aStem:aGroup --queryFilterType01=FIND_BY_GROUP_NAME_APPROXIMATE --groupName01=aStem:aGroup --queryFilterType1=FIND_BY_GROUP_NAME_APPROXIMATE --groupName1=aStem:aGroup",
5500 " "));
5501 System.out.flush();
5502 output = new String(baos.toByteArray());
5503
5504 System.setOut(systemOut);
5505
5506 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5507
5508 matcher = pattern.matcher(outputLines[0]);
5509
5510 assertEquals(output, 1, outputLines.length);
5511 assertTrue(outputLines[0], matcher.matches());
5512
5513 assertEquals(output, "0", matcher.group(1));
5514 assertEquals(output, "aStem:aGroup", matcher.group(2));
5515 assertEquals(output, "aStem:aGroup", matcher.group(3));
5516
5517 assertTrue(GrouperClientWs.mostRecentRequest.contains("OR")
5518 && GrouperClientWs.mostRecentRequest
5519 .contains("FIND_BY_GROUP_NAME_APPROXIMATE"));
5520
5521
5522
5523
5524 Group group1 = Group.saveGroup(grouperSession, "aStem:aGroup1", null, "aStem:aGroup1", null, null, null, true);
5525
5526 baos = new ByteArrayOutputStream();
5527 System.setOut(new PrintStream(baos));
5528
5529 GrouperClient
5530 .main(GrouperClientUtils
5531 .splitTrim(
5532 "--operation=findGroupsWs --groupNames=aStem:aGroup,aStem:aGroup1",
5533 " "));
5534 System.out.flush();
5535 output = new String(baos.toByteArray());
5536
5537 System.setOut(systemOut);
5538
5539 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5540
5541 assertEquals(output, 2, outputLines.length);
5542 matcher = pattern.matcher(outputLines[0]);
5543
5544 assertTrue(outputLines[0], matcher.matches());
5545
5546 assertEquals(output, "0", matcher.group(1));
5547 assertEquals(output, "aStem:aGroup", matcher.group(2));
5548 assertEquals(output, "aStem:aGroup", matcher.group(3));
5549
5550 matcher = pattern.matcher(outputLines[1]);
5551
5552 assertTrue(outputLines[1], matcher.matches());
5553
5554 assertEquals(output, "1", matcher.group(1));
5555 assertEquals(output, "aStem:aGroup1", matcher.group(2));
5556 assertEquals(output, "aStem:aGroup1", matcher.group(3));
5557
5558
5559
5560
5561 group1 = Group.saveGroup(grouperSession, "aStem:aGroup1", null, "aStem:aGroup1", null, null, null, true);
5562
5563 baos = new ByteArrayOutputStream();
5564 System.setOut(new PrintStream(baos));
5565
5566 GrouperClient
5567 .main(GrouperClientUtils
5568 .splitTrim(
5569 "--operation=findGroupsWs --groupIdIndexes=" + group1.getIdIndex(),
5570 " "));
5571 System.out.flush();
5572 output = new String(baos.toByteArray());
5573
5574 System.setOut(systemOut);
5575
5576 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5577
5578 assertEquals(output, 1, outputLines.length);
5579 matcher = pattern.matcher(outputLines[0]);
5580
5581 assertTrue(outputLines[0], matcher.matches());
5582
5583 assertEquals(output, "0", matcher.group(1));
5584 assertEquals(output, "aStem:aGroup1", matcher.group(2));
5585 assertEquals(output, "aStem:aGroup1", matcher.group(3));
5586
5587
5588
5589
5590
5591 baos = new ByteArrayOutputStream();
5592 System.setOut(new PrintStream(baos));
5593
5594 GrouperClient
5595 .main(GrouperClientUtils
5596 .splitTrim(
5597 "--operation=findGroupsWs --groupUuids=" + group.getId() + "," + group1.getId(),
5598 " "));
5599 System.out.flush();
5600 output = new String(baos.toByteArray());
5601
5602 System.setOut(systemOut);
5603
5604 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5605
5606 assertEquals(output, 2, outputLines.length);
5607 matcher = pattern.matcher(outputLines[0]);
5608
5609 assertTrue(outputLines[0], matcher.matches());
5610
5611 assertEquals(output, "0", matcher.group(1));
5612 assertEquals(output, "aStem:aGroup", matcher.group(2));
5613 assertEquals(output, "aStem:aGroup", matcher.group(3));
5614
5615 matcher = pattern.matcher(outputLines[1]);
5616
5617 assertTrue(outputLines[1], matcher.matches());
5618
5619 assertEquals(output, "1", matcher.group(1));
5620 assertEquals(output, "aStem:aGroup1", matcher.group(2));
5621 assertEquals(output, "aStem:aGroup1", matcher.group(3));
5622
5623
5624
5625
5626 Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null, "aStem:aGroup2", null, null, null, true);
5627
5628 baos = new ByteArrayOutputStream();
5629 System.setOut(new PrintStream(baos));
5630
5631 GrouperClient
5632 .main(GrouperClientUtils
5633 .splitTrim(
5634 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:a% --stemName=aStem --ascending=T --sortString=name --pageNumber=1 --pageSize=2",
5635 " "));
5636 System.out.flush();
5637 output = new String(baos.toByteArray());
5638
5639 System.setOut(systemOut);
5640
5641 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5642
5643 assertEquals(output, 2, outputLines.length);
5644 matcher = pattern.matcher(outputLines[0]);
5645
5646 assertTrue(outputLines[0], matcher.matches());
5647
5648 assertEquals(output, "0", matcher.group(1));
5649 assertEquals(output, "aStem:aGroup", matcher.group(2));
5650 assertEquals(output, "aStem:aGroup", matcher.group(3));
5651
5652 matcher = pattern.matcher(outputLines[1]);
5653
5654 assertTrue(outputLines[1], matcher.matches());
5655
5656 assertEquals(output, "1", matcher.group(1));
5657 assertEquals(output, "aStem:aGroup1", matcher.group(2));
5658 assertEquals(output, "aStem:aGroup1", matcher.group(3));
5659
5660
5661
5662
5663 baos = new ByteArrayOutputStream();
5664 System.setOut(new PrintStream(baos));
5665
5666 GrouperClient
5667 .main(GrouperClientUtils
5668 .splitTrim(
5669 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:a% --stemName=aStem --ascending=T --sortString=name --pageNumber=1 --pageSize=2",
5670 " "));
5671 System.out.flush();
5672 output = new String(baos.toByteArray());
5673
5674 System.setOut(systemOut);
5675
5676 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5677
5678 assertEquals(output, 2, outputLines.length);
5679 matcher = pattern.matcher(outputLines[0]);
5680
5681 assertTrue(outputLines[0], matcher.matches());
5682
5683 assertEquals(output, "0", matcher.group(1));
5684 assertEquals(output, "aStem:aGroup", matcher.group(2));
5685 assertEquals(output, "aStem:aGroup", matcher.group(3));
5686
5687 matcher = pattern.matcher(outputLines[1]);
5688
5689 assertTrue(outputLines[1], matcher.matches());
5690
5691 assertEquals(output, "1", matcher.group(1));
5692 assertEquals(output, "aStem:aGroup1", matcher.group(2));
5693 assertEquals(output, "aStem:aGroup1", matcher.group(3));
5694
5695
5696
5697
5698
5699 baos = new ByteArrayOutputStream();
5700 System.setOut(new PrintStream(baos));
5701
5702 GrouperClient
5703 .main(GrouperClientUtils
5704 .splitTrim(
5705 "--operation=findGroupsWs --queryFilterType=FIND_BY_STEM_NAME --stemName=aStem --ascending=T --sortString=name --pageNumber=2 --pageSize=2",
5706 " "));
5707 System.out.flush();
5708 output = new String(baos.toByteArray());
5709
5710 System.setOut(systemOut);
5711
5712 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5713
5714 assertEquals(output, 1, outputLines.length);
5715 matcher = pattern.matcher(outputLines[0]);
5716
5717 assertTrue(outputLines[0], matcher.matches());
5718
5719 assertEquals(output, "0", matcher.group(1));
5720 assertEquals(output, "aStem:aGroup2", matcher.group(2));
5721 assertEquals(output, "aStem:aGroup2", matcher.group(3));
5722
5723
5724
5725 baos = new ByteArrayOutputStream();
5726 System.setOut(new PrintStream(baos));
5727
5728 GrouperClient
5729 .main(GrouperClientUtils
5730 .splitTrim(
5731 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --stemName=aStem --typeOfGroups=group",
5732 " "));
5733 System.out.flush();
5734 output = new String(baos.toByteArray());
5735
5736 System.setOut(systemOut);
5737
5738 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5739
5740 matcher = pattern.matcher(outputLines[0]);
5741
5742 assertEquals(output, 3, outputLines.length);
5743 assertTrue(outputLines[0], matcher.matches());
5744
5745 assertEquals(output, "0", matcher.group(1));
5746 assertEquals(output, "aStem:aGroup", matcher.group(2));
5747 assertEquals(output, "aStem:aGroup", matcher.group(3));
5748
5749 matcher = pattern.matcher(outputLines[1]);
5750 assertTrue(outputLines[1], matcher.matches());
5751
5752 assertEquals(output, "1", matcher.group(1));
5753 assertEquals(output, "aStem:aGroup1", matcher.group(2));
5754 assertEquals(output, "aStem:aGroup1", matcher.group(3));
5755
5756 matcher = pattern.matcher(outputLines[2]);
5757 assertTrue(outputLines[2], matcher.matches());
5758
5759 assertEquals(output, "2", matcher.group(1));
5760 assertEquals(output, "aStem:aGroup2", matcher.group(2));
5761 assertEquals(output, "aStem:aGroup2", matcher.group(3));
5762
5763 assertTrue(GrouperClientWs.mostRecentRequest.contains("typeOfGroups")
5764 && GrouperClientWs.mostRecentRequest.contains(">group<"));
5765
5766
5767
5768 baos = new ByteArrayOutputStream();
5769 System.setOut(new PrintStream(baos));
5770
5771 GrouperClient
5772 .main(GrouperClientUtils
5773 .splitTrim(
5774 "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --stemName=aStem --typeOfGroups=role",
5775 " "));
5776 System.out.flush();
5777 output = new String(baos.toByteArray());
5778
5779 System.setOut(systemOut);
5780
5781 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5782
5783 assertEquals(output, 0, GrouperUtil.length(outputLines));
5784
5785 assertTrue(GrouperClientWs.mostRecentRequest.contains("typeOfGroups")
5786 && GrouperClientWs.mostRecentRequest.contains(">role<"));
5787
5788
5789
5790 } finally {
5791 System.setOut(systemOut);
5792 }
5793
5794 }
5795
5796
5797
5798
5799 public void testFindStems() throws Exception {
5800
5801 PrintStream systemOut = System.out;
5802
5803 ByteArrayOutputStream baos = new ByteArrayOutputStream();
5804 System.setOut(new PrintStream(baos));
5805
5806 try {
5807
5808 GrouperClient
5809 .main(GrouperClientUtils
5810 .splitTrim(
5811 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --stemName=aStem",
5812 " "));
5813 System.out.flush();
5814 String output = new String(baos.toByteArray());
5815
5816 System.setOut(systemOut);
5817
5818 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
5819
5820 Pattern pattern = Pattern
5821 .compile("^Index (\\d+): name: (.+), displayName: (.+)$");
5822 Matcher matcher = pattern.matcher(outputLines[0]);
5823
5824 assertEquals(output, 1, outputLines.length);
5825 assertTrue(outputLines[0], matcher.matches());
5826
5827 assertEquals(output, "0", matcher.group(1));
5828 assertEquals(output, "aStem", matcher.group(2));
5829 assertEquals(output, "aStem", matcher.group(3));
5830
5831
5832
5833 baos = new ByteArrayOutputStream();
5834 System.setOut(new PrintStream(baos));
5835
5836
5837 try {
5838 GrouperClient
5839 .main(GrouperClientUtils
5840 .splitTrim(
5841 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --groupName=aStem:aGroup --ousdfsdfate=${index}",
5842 " "));
5843 } catch (Exception e) {
5844 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
5845 }
5846 System.out.flush();
5847
5848 System.setOut(systemOut);
5849
5850
5851
5852 baos = new ByteArrayOutputStream();
5853 System.setOut(new PrintStream(baos));
5854
5855
5856 GrouperClient
5857 .main(GrouperClientUtils
5858 .splitTrim(
5859 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --stemName=aStem --outputTemplate=${index}",
5860 " "));
5861
5862 System.out.flush();
5863
5864 output = new String(baos.toByteArray());
5865
5866 System.setOut(systemOut);
5867
5868 assertEquals("0", output);
5869
5870
5871
5872 baos = new ByteArrayOutputStream();
5873 System.setOut(new PrintStream(baos));
5874
5875 GrouperClient
5876 .main(GrouperClientUtils
5877 .splitTrim(
5878 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_PARENT_STEM_NAME --parentStemName=aStem --parentStemNameScope=ALL_IN_SUBTREE",
5879 " "));
5880 System.out.flush();
5881 output = new String(baos.toByteArray());
5882
5883 System.setOut(systemOut);
5884
5885 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5886
5887 matcher = pattern.matcher(outputLines[0]);
5888
5889 assertEquals(output, 1, outputLines.length);
5890 assertTrue(outputLines[0], matcher.matches());
5891
5892 assertEquals(output, "0", matcher.group(1));
5893 assertEquals(output, "aStem:aStem0", matcher.group(2));
5894 assertEquals(output, "aStem:aStem0", matcher.group(3));
5895
5896 assertTrue(GrouperClientWs.mostRecentRequest,
5897 GrouperClientWs.mostRecentRequest.contains("parentStemName")
5898 && GrouperClientWs.mostRecentRequest
5899 .contains("parentStemNameScope"));
5900
5901
5902
5903 baos = new ByteArrayOutputStream();
5904 System.setOut(new PrintStream(baos));
5905
5906 GrouperClient
5907 .main(GrouperClientUtils
5908 .splitTrim(
5909 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --stemName=aStem --paramName0=whatever --paramValue0=someValue",
5910 " "));
5911 System.out.flush();
5912 output = new String(baos.toByteArray());
5913
5914 System.setOut(systemOut);
5915
5916 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5917
5918 matcher = pattern.matcher(outputLines[0]);
5919
5920 assertEquals(output, 1, outputLines.length);
5921 assertTrue(outputLines[0], matcher.matches());
5922
5923 assertEquals(output, "0", matcher.group(1));
5924 assertEquals(output, "aStem", matcher.group(2));
5925 assertEquals(output, "aStem", matcher.group(3));
5926
5927 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
5928 && GrouperClientWs.mostRecentRequest.contains("someValue"));
5929
5930
5931
5932 baos = new ByteArrayOutputStream();
5933 System.setOut(new PrintStream(baos));
5934
5935 GrouperClient
5936 .main(GrouperClientUtils
5937 .splitTrim(
5938 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_UUID --stemUuid=abc",
5939 " "));
5940 System.out.flush();
5941 output = new String(baos.toByteArray());
5942
5943 System.setOut(systemOut);
5944
5945 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5946
5947 assertTrue(output, GrouperClientUtils.isBlank(output));
5948
5949 assertTrue(GrouperClientWs.mostRecentRequest.contains("stemUuid")
5950 && GrouperClientWs.mostRecentRequest.contains("abc"));
5951
5952
5953
5954 baos = new ByteArrayOutputStream();
5955 System.setOut(new PrintStream(baos));
5956
5957 GrouperClient
5958 .main(GrouperClientUtils
5959 .splitTrim(
5960 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_APPROXIMATE_ATTRIBUTE --stemAttributeName=name --stemAttributeValue=aStem",
5961 " "));
5962 System.out.flush();
5963 output = new String(baos.toByteArray());
5964
5965 System.setOut(systemOut);
5966
5967 outputLines = GrouperClientUtils.splitTrim(output, "\n");
5968
5969 matcher = pattern.matcher(outputLines[0]);
5970
5971 assertEquals(output, 2, outputLines.length);
5972 assertTrue(outputLines[0], matcher.matches());
5973
5974 assertEquals(output, "0", matcher.group(1));
5975 assertEquals(output, "aStem", matcher.group(2));
5976 assertEquals(output, "aStem", matcher.group(3));
5977
5978 matcher = pattern.matcher(outputLines[1]);
5979 assertTrue(outputLines[1], matcher.matches());
5980
5981 assertEquals(output, "1", matcher.group(1));
5982 assertEquals(output, "aStem:aStem0", matcher.group(2));
5983 assertEquals(output, "aStem:aStem0", matcher.group(3));
5984
5985 assertTrue(GrouperClientWs.mostRecentRequest
5986 .contains("FIND_BY_APPROXIMATE_ATTRIBUTE")
5987 && GrouperClientWs.mostRecentRequest.contains("stemAttributeName")
5988 && GrouperClientWs.mostRecentRequest.contains("aStem"));
5989
5990
5991
5992 baos = new ByteArrayOutputStream();
5993 System.setOut(new PrintStream(baos));
5994
5995 GrouperClient
5996 .main(GrouperClientUtils
5997 .splitTrim(
5998 "--operation=findStemsWs --stemQueryFilterType=OR --stemQueryFilterType0=OR --stemQueryFilterType00=FIND_BY_STEM_NAME --stemName00=aStem --stemQueryFilterType01=FIND_BY_STEM_NAME --stemName01=aStem --stemQueryFilterType1=FIND_BY_STEM_NAME --stemName1=aStem",
5999 " "));
6000 System.out.flush();
6001 output = new String(baos.toByteArray());
6002
6003 System.setOut(systemOut);
6004
6005 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6006
6007 matcher = pattern.matcher(outputLines[0]);
6008
6009 assertEquals(output, 1, outputLines.length);
6010 assertTrue(outputLines[0], matcher.matches());
6011
6012 assertEquals(output, "0", matcher.group(1));
6013 assertEquals(output, "aStem", matcher.group(2));
6014 assertEquals(output, "aStem", matcher.group(3));
6015
6016 assertTrue(GrouperClientWs.mostRecentRequest.contains("OR")
6017 && GrouperClientWs.mostRecentRequest.contains("FIND_BY_STEM_NAME"));
6018
6019
6020
6021 GrouperSession grouperSession = GrouperSession.startRootSession();
6022 Stem aStem = StemFinder.findByName(grouperSession, "aStem", true);
6023 Stem aStem0 = StemFinder.findByName(grouperSession, "aStem:aStem0", true);
6024
6025 baos = new ByteArrayOutputStream();
6026 System.setOut(new PrintStream(baos));
6027
6028 GrouperClient
6029 .main(GrouperClientUtils
6030 .splitTrim(
6031 "--operation=findStemsWs --stemNames=aStem,aStem:aStem0",
6032 " "));
6033 System.out.flush();
6034 output = new String(baos.toByteArray());
6035
6036 System.setOut(systemOut);
6037
6038 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6039
6040 assertEquals(output, 2, outputLines.length);
6041 matcher = pattern.matcher(outputLines[0]);
6042
6043 assertTrue(outputLines[0], matcher.matches());
6044
6045 assertEquals(output, "0", matcher.group(1));
6046 assertEquals(output, "aStem", matcher.group(2));
6047 assertEquals(output, "aStem", matcher.group(3));
6048
6049 matcher = pattern.matcher(outputLines[1]);
6050
6051 assertTrue(outputLines[1], matcher.matches());
6052
6053 assertEquals(output, "1", matcher.group(1));
6054 assertEquals(output, "aStem:aStem0", matcher.group(2));
6055 assertEquals(output, "aStem:aStem0", matcher.group(3));
6056
6057
6058
6059
6060 baos = new ByteArrayOutputStream();
6061 System.setOut(new PrintStream(baos));
6062
6063 GrouperClient
6064 .main(GrouperClientUtils
6065 .splitTrim(
6066 "--operation=findStemsWs --stemIdIndexes=" + aStem.getIdIndex(),
6067 " "));
6068 System.out.flush();
6069 output = new String(baos.toByteArray());
6070
6071 System.setOut(systemOut);
6072
6073 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6074
6075 assertEquals(output, 1, outputLines.length);
6076 matcher = pattern.matcher(outputLines[0]);
6077
6078 assertTrue(outputLines[0], matcher.matches());
6079
6080 assertEquals(output, "0", matcher.group(1));
6081 assertEquals(output, "aStem", matcher.group(2));
6082 assertEquals(output, "aStem", matcher.group(3));
6083
6084
6085
6086
6087 baos = new ByteArrayOutputStream();
6088 System.setOut(new PrintStream(baos));
6089
6090 GrouperClient
6091 .main(GrouperClientUtils
6092 .splitTrim(
6093 "--operation=findStemsWs --stemUuids=" + aStem.getUuid() + "," + aStem0.getUuid(),
6094 " "));
6095 System.out.flush();
6096 output = new String(baos.toByteArray());
6097
6098 System.setOut(systemOut);
6099
6100 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6101
6102 assertEquals(output, 2, outputLines.length);
6103 matcher = pattern.matcher(outputLines[0]);
6104
6105 assertTrue(outputLines[0], matcher.matches());
6106
6107 assertEquals(output, "0", matcher.group(1));
6108 assertEquals(output, "aStem", matcher.group(2));
6109 assertEquals(output, "aStem", matcher.group(3));
6110
6111 matcher = pattern.matcher(outputLines[1]);
6112
6113 assertTrue(outputLines[1], matcher.matches());
6114
6115 assertEquals(output, "1", matcher.group(1));
6116 assertEquals(output, "aStem:aStem0", matcher.group(2));
6117 assertEquals(output, "aStem:aStem0", matcher.group(3));
6118
6119
6120
6121
6122 new StemSave(grouperSession).assignName("aStem:aStem1").save();
6123 new StemSave(grouperSession).assignName("aStem:aStem2").save();
6124
6125
6126 baos = new ByteArrayOutputStream();
6127 System.setOut(new PrintStream(baos));
6128
6129 GrouperClient
6130 .main(GrouperClientUtils
6131 .splitTrim(
6132 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME_APPROXIMATE --stemName=aStem:a% --parentStemName=aStem --ascending=T --sortString=name --pageNumber=1 --pageSize=2",
6133 " "));
6134 System.out.flush();
6135 output = new String(baos.toByteArray());
6136
6137 System.setOut(systemOut);
6138
6139 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6140
6141 assertEquals(output, 2, outputLines.length);
6142 matcher = pattern.matcher(outputLines[0]);
6143
6144 assertTrue(outputLines[0], matcher.matches());
6145
6146 assertEquals(output, "0", matcher.group(1));
6147 assertEquals(output, "aStem:aStem0", matcher.group(2));
6148
6149 matcher = pattern.matcher(outputLines[1]);
6150
6151 assertTrue(outputLines[1], matcher.matches());
6152
6153 assertEquals(output, "1", matcher.group(1));
6154 assertEquals(output, "aStem:aStem1", matcher.group(2));
6155
6156
6157
6158
6159
6160 new StemSave(grouperSession).assignName("aStem:aStem1").save();
6161 new StemSave(grouperSession).assignName("aStem:aStem2").save();
6162
6163
6164 baos = new ByteArrayOutputStream();
6165 System.setOut(new PrintStream(baos));
6166
6167 GrouperClient
6168 .main(GrouperClientUtils
6169 .splitTrim(
6170 "--operation=findStemsWs --stemQueryFilterType=FIND_BY_PARENT_STEM_NAME --parentStemName=aStem --ascending=T --sortString=name --pageNumber=2 --pageSize=2",
6171 " "));
6172 System.out.flush();
6173 output = new String(baos.toByteArray());
6174
6175 System.setOut(systemOut);
6176
6177 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6178
6179 assertEquals(output, 1, outputLines.length);
6180 matcher = pattern.matcher(outputLines[0]);
6181
6182 assertTrue(outputLines[0], matcher.matches());
6183
6184 assertEquals(output, "0", matcher.group(1));
6185 assertEquals(output, "aStem:aStem2", matcher.group(2));
6186
6187
6188
6189 } finally {
6190 System.setOut(systemOut);
6191 }
6192
6193 }
6194
6195
6196
6197
6198
6199
6200
6201 public void testGetMembersSlash() throws Exception {
6202
6203 GrouperSession grouperSession = GrouperSession.startRootSession();
6204 Group group = Group.saveGroup(grouperSession, "aStem:aGroup/1", null,
6205 "aStem:aGroup/1", "aGroup", null, null, true);
6206
6207
6208 String wsUserLabel = GrouperClientUtils.propertiesValue(
6209 "grouperClient.webService.user.label", true);
6210 String wsUserString = GrouperClientUtils.propertiesValue(
6211 "grouperClient.webService." + wsUserLabel, true);
6212 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
6213
6214 group.grantPriv(wsUser, AccessPrivilege.READ, false);
6215 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
6216 group.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
6217
6218
6219
6220
6221 PrintStream systemOut = System.out;
6222
6223 ByteArrayOutputStream baos = new ByteArrayOutputStream();
6224 System.setOut(new PrintStream(baos));
6225
6226 try {
6227
6228
6229
6230 GrouperClient.main(GrouperClientUtils.splitTrim(
6231 "--operation=addMemberWs --groupName=aStem:aGroup/1 --subjectIds=test.subject.0 --outputTemplate=Index${index}:success:${resultMetadata.success}:code:${resultMetadata.resultCode}:${wsSubject.id}:${wsAddMemberResults.wsGroupAssigned.name}$newline$${index}",
6232 " "));
6233 System.out.flush();
6234 String output = new String(baos.toByteArray());
6235
6236 System.setOut(systemOut);
6237
6238 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
6239
6240
6241 Pattern pattern = Pattern
6242 .compile("^Index(\\d+):success:T:code:([A-Z_]+?):(.+?):(.*+)$");
6243 Matcher matcher = pattern.matcher(outputLines[0]);
6244
6245 assertTrue(outputLines[0], matcher.matches());
6246
6247 assertEquals(outputLines[0], "0", matcher.group(1));
6248 assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
6249 assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
6250 assertEquals(outputLines[0], "aStem:aGroup/1", matcher.group(4));
6251
6252
6253
6254 baos = new ByteArrayOutputStream();
6255 System.setOut(new PrintStream(baos));
6256
6257 GrouperClient.main(GrouperClientUtils.splitTrim(
6258 "--operation=getMembersWs --groupNames=aStem:aGroup/1",
6259 " "));
6260 System.out.flush();
6261 output = new String(baos.toByteArray());
6262
6263 System.setOut(systemOut);
6264
6265 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6266
6267
6268
6269 pattern = Pattern
6270 .compile("^GroupIndex (\\d+)\\: success\\: ([TF])\\: code: ([A-Z_]+)\\: group\\: (.*)\\: subjectIndex\\: (\\d+)\\: (.*)$");
6271 matcher = pattern.matcher(outputLines[0]);
6272
6273 assertTrue(outputLines[0], matcher.matches());
6274
6275 assertEquals(outputLines[0], "0", matcher.group(1));
6276 assertEquals(outputLines[0], "T", matcher.group(2));
6277 assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6278 assertEquals(outputLines[0], "aStem:aGroup/1", matcher.group(4));
6279 assertEquals(outputLines[0], "0", matcher.group(5));
6280 String subjectId = matcher.group(6);
6281 assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.0",
6282 subjectId));
6283 } finally {
6284 System.setOut(systemOut);
6285 }
6286 }
6287
6288
6289
6290
6291 public void testGetMembers() throws Exception {
6292
6293
6294 GrouperSession grouperSession = GrouperSession.startRootSession();
6295 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
6296 "aStem:aGroup", "aGroup", null, null, true);
6297 Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
6298 "aStem:aGroup2", "aGroup2", null, null, true);
6299
6300
6301 String wsUserLabel = GrouperClientUtils.propertiesValue(
6302 "grouperClient.webService.user.label", true);
6303 String wsUserString = GrouperClientUtils.propertiesValue(
6304 "grouperClient.webService." + wsUserLabel, true);
6305 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
6306
6307 group.grantPriv(wsUser, AccessPrivilege.READ, false);
6308 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
6309 group2.grantPriv(wsUser, AccessPrivilege.READ, false);
6310 group2.grantPriv(wsUser, AccessPrivilege.VIEW, false);
6311
6312
6313 group.addMember(SubjectTestHelper.SUBJ4, false);
6314 group.deleteMember(SubjectTestHelper.SUBJ4, false);
6315 Thread.sleep(100);
6316 Timestamp pointInTimeFrom = new Timestamp(new Date().getTime());
6317 Thread.sleep(100);
6318
6319 group.addMember(SubjectTestHelper.SUBJ5, false);
6320 group.deleteMember(SubjectTestHelper.SUBJ5, false);
6321
6322
6323 group.addMember(SubjectTestHelper.SUBJ0, false);
6324 group.addMember(SubjectTestHelper.SUBJ1, false);
6325 group2.addMember(SubjectTestHelper.SUBJ2, false);
6326 group2.addMember(SubjectTestHelper.SUBJ3, false);
6327
6328
6329 group.addMember(SubjectTestHelper.SUBJ6, false);
6330 group.deleteMember(SubjectTestHelper.SUBJ6, false);
6331 Thread.sleep(100);
6332 Timestamp pointInTimeTo = new Timestamp(new Date().getTime());
6333 Thread.sleep(100);
6334
6335 group.addMember(SubjectTestHelper.SUBJ7, false);
6336 group.deleteMember(SubjectTestHelper.SUBJ7, false);
6337 ChangeLogTempToEntity.convertRecords();
6338
6339 PrintStream systemOut = System.out;
6340
6341 ByteArrayOutputStream baos = new ByteArrayOutputStream();
6342 System.setOut(new PrintStream(baos));
6343
6344 try {
6345
6346 GrouperClient.main(GrouperClientUtils.splitTrim(
6347 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2",
6348 " "));
6349 System.out.flush();
6350 String output = new String(baos.toByteArray());
6351
6352 System.setOut(systemOut);
6353
6354 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
6355
6356
6357
6358 Pattern pattern = Pattern
6359 .compile("^GroupIndex (\\d+)\\: success\\: ([TF])\\: code: ([A-Z_]+)\\: group\\: (.*)\\: subjectIndex\\: (\\d+)\\: (.*)$");
6360 Matcher matcher = pattern.matcher(outputLines[0]);
6361
6362 assertTrue(outputLines[0], matcher.matches());
6363
6364 assertEquals(outputLines[0], "0", matcher.group(1));
6365 assertEquals(outputLines[0], "T", matcher.group(2));
6366 assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6367 assertEquals(outputLines[0], "aStem:aGroup", matcher.group(4));
6368 assertEquals(outputLines[0], "0", matcher.group(5));
6369 String subjectId = matcher.group(6);
6370 assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.0",
6371 subjectId)
6372 || GrouperClientUtils.equals("test.subject.1", subjectId));
6373
6374 matcher = pattern.matcher(outputLines[1]);
6375
6376 assertTrue(outputLines[1], matcher.matches());
6377
6378 assertEquals(outputLines[1], "0", matcher.group(1));
6379 assertEquals(outputLines[1], "T", matcher.group(2));
6380 assertEquals(outputLines[1], "SUCCESS", matcher.group(3));
6381 assertEquals(outputLines[1], "aStem:aGroup", matcher.group(4));
6382 assertEquals(outputLines[1], "1", matcher.group(5));
6383 subjectId = matcher.group(6);
6384 assertTrue(outputLines[1], GrouperClientUtils.equals("test.subject.0",
6385 subjectId)
6386 || GrouperClientUtils.equals("test.subject.1", subjectId));
6387
6388 matcher = pattern.matcher(outputLines[2]);
6389
6390 assertTrue(outputLines[2], matcher.matches());
6391
6392 assertEquals(outputLines[2], "1", matcher.group(1));
6393 assertEquals(outputLines[2], "T", matcher.group(2));
6394 assertEquals(outputLines[2], "SUCCESS", matcher.group(3));
6395 assertEquals(outputLines[2], "aStem:aGroup2", matcher.group(4));
6396 assertEquals(outputLines[2], "0", matcher.group(5));
6397 subjectId = matcher.group(6);
6398 assertTrue(outputLines[2], GrouperClientUtils.equals("test.subject.2",
6399 subjectId)
6400 || GrouperClientUtils.equals("test.subject.3", subjectId));
6401
6402 matcher = pattern.matcher(outputLines[3]);
6403
6404 assertTrue(outputLines[3], matcher.matches());
6405
6406 assertEquals(outputLines[3], "1", matcher.group(1));
6407 assertEquals(outputLines[3], "T", matcher.group(2));
6408 assertEquals(outputLines[3], "SUCCESS", matcher.group(3));
6409 assertEquals(outputLines[3], "aStem:aGroup2", matcher.group(4));
6410 assertEquals(outputLines[3], "1", matcher.group(5));
6411 subjectId = matcher.group(6);
6412 assertTrue(outputLines[3], GrouperClientUtils.equals("test.subject.2",
6413 subjectId)
6414 || GrouperClientUtils.equals("test.subject.3", subjectId));
6415
6416 assertTrue(GrouperClientWs.mostRecentRequest,
6417 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6418 assertTrue(GrouperClientWs.mostRecentRequest,
6419 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6420 assertTrue(GrouperClientWs.mostRecentRequest,
6421 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6422 assertTrue(GrouperClientWs.mostRecentRequest,
6423 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6424 assertTrue(GrouperClientWs.mostRecentRequest,
6425 !GrouperClientWs.mostRecentRequest.contains("params"));
6426 assertTrue(GrouperClientWs.mostRecentRequest,
6427 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6428 assertTrue(GrouperClientWs.mostRecentRequest,
6429 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6430 assertTrue(GrouperClientWs.mostRecentRequest,
6431 !GrouperClientWs.mostRecentRequest.contains("pageSize"));
6432 assertTrue(GrouperClientWs.mostRecentRequest,
6433 !GrouperClientWs.mostRecentRequest.contains("pageNumber"));
6434 assertTrue(GrouperClientWs.mostRecentRequest,
6435 !GrouperClientWs.mostRecentRequest.contains("sortString"));
6436 assertTrue(GrouperClientWs.mostRecentRequest,
6437 !GrouperClientWs.mostRecentRequest.contains("ascending"));
6438
6439
6440
6441
6442 baos = new ByteArrayOutputStream();
6443 System.setOut(new PrintStream(baos));
6444
6445 ArrayList<String> args = new ArrayList<String>();
6446 args.add("--operation=getMembersWs");
6447 args.add("--groupNames=aStem:aGroup");
6448 args.add("--pageSize=1");
6449 args.add("--pageNumber=2");
6450 args.add("--sortString=subjectId");
6451 args.add("--ascending=true");
6452 GrouperClient.main(args.toArray(new String[0]));
6453
6454 System.out.flush();
6455 output = new String(baos.toByteArray());
6456 System.setOut(systemOut);
6457
6458 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6459
6460 assertEquals(1, outputLines.length);
6461
6462 matcher = pattern.matcher(outputLines[0]);
6463
6464 assertTrue(outputLines[0], matcher.matches());
6465
6466 assertEquals(outputLines[0], "0", matcher.group(1));
6467 assertEquals(outputLines[0], "T", matcher.group(2));
6468 assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6469 assertEquals(outputLines[0], "aStem:aGroup", matcher.group(4));
6470 assertEquals(outputLines[0], "0", matcher.group(5));
6471 subjectId = matcher.group(6);
6472 assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.1",
6473 subjectId));
6474
6475
6476 assertTrue(GrouperClientWs.mostRecentRequest,
6477 GrouperClientWs.mostRecentRequest.contains("pageSize"));
6478 assertTrue(GrouperClientWs.mostRecentRequest,
6479 GrouperClientWs.mostRecentRequest.contains("pageNumber"));
6480 assertTrue(GrouperClientWs.mostRecentRequest,
6481 GrouperClientWs.mostRecentRequest.contains("sortString"));
6482 assertTrue(GrouperClientWs.mostRecentRequest,
6483 GrouperClientWs.mostRecentRequest.contains("ascending"));
6484
6485
6486
6487
6488
6489 baos = new ByteArrayOutputStream();
6490 System.setOut(new PrintStream(baos));
6491
6492 args = new ArrayList<String>();
6493 args.add("--operation=getMembersWs");
6494 args.add("--groupNames=aStem:aGroup,aStem:aGroup2");
6495 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTimeFrom));
6496 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTimeTo));
6497 GrouperClient.main(args.toArray(new String[0]));
6498
6499 System.out.flush();
6500 output = new String(baos.toByteArray());
6501 System.setOut(systemOut);
6502
6503 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6504
6505 matcher = pattern.matcher(outputLines[0]);
6506
6507 assertTrue(outputLines[0], matcher.matches());
6508
6509 assertEquals(outputLines[0], "0", matcher.group(1));
6510 assertEquals(outputLines[0], "T", matcher.group(2));
6511 assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6512 assertEquals(outputLines[0], "aStem:aGroup", matcher.group(4));
6513 assertEquals(outputLines[0], "0", matcher.group(5));
6514 subjectId = matcher.group(6);
6515 assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6516 GrouperClientUtils.equals("test.subject.1", subjectId) ||
6517 GrouperClientUtils.equals("test.subject.5", subjectId) ||
6518 GrouperClientUtils.equals("test.subject.6", subjectId));
6519
6520 matcher = pattern.matcher(outputLines[1]);
6521
6522 assertTrue(outputLines[1], matcher.matches());
6523
6524 assertEquals(outputLines[1], "0", matcher.group(1));
6525 assertEquals(outputLines[1], "T", matcher.group(2));
6526 assertEquals(outputLines[1], "SUCCESS", matcher.group(3));
6527 assertEquals(outputLines[1], "aStem:aGroup", matcher.group(4));
6528 assertEquals(outputLines[1], "1", matcher.group(5));
6529 subjectId = matcher.group(6);
6530 assertTrue(outputLines[1], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6531 GrouperClientUtils.equals("test.subject.1", subjectId) ||
6532 GrouperClientUtils.equals("test.subject.5", subjectId) ||
6533 GrouperClientUtils.equals("test.subject.6", subjectId));
6534
6535 matcher = pattern.matcher(outputLines[2]);
6536
6537 assertTrue(outputLines[2], matcher.matches());
6538
6539 assertEquals(outputLines[2], "0", matcher.group(1));
6540 assertEquals(outputLines[2], "T", matcher.group(2));
6541 assertEquals(outputLines[2], "SUCCESS", matcher.group(3));
6542 assertEquals(outputLines[2], "aStem:aGroup", matcher.group(4));
6543 assertEquals(outputLines[2], "2", matcher.group(5));
6544 subjectId = matcher.group(6);
6545 assertTrue(outputLines[2], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6546 GrouperClientUtils.equals("test.subject.1", subjectId) ||
6547 GrouperClientUtils.equals("test.subject.5", subjectId) ||
6548 GrouperClientUtils.equals("test.subject.6", subjectId));
6549
6550 matcher = pattern.matcher(outputLines[3]);
6551
6552 assertTrue(outputLines[3], matcher.matches());
6553
6554 assertEquals(outputLines[3], "0", matcher.group(1));
6555 assertEquals(outputLines[3], "T", matcher.group(2));
6556 assertEquals(outputLines[3], "SUCCESS", matcher.group(3));
6557 assertEquals(outputLines[3], "aStem:aGroup", matcher.group(4));
6558 assertEquals(outputLines[3], "3", matcher.group(5));
6559 subjectId = matcher.group(6);
6560 assertTrue(outputLines[3], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6561 GrouperClientUtils.equals("test.subject.1", subjectId) ||
6562 GrouperClientUtils.equals("test.subject.5", subjectId) ||
6563 GrouperClientUtils.equals("test.subject.6", subjectId));
6564
6565 matcher = pattern.matcher(outputLines[4]);
6566
6567 assertTrue(outputLines[4], matcher.matches());
6568
6569 assertEquals(outputLines[4], "1", matcher.group(1));
6570 assertEquals(outputLines[4], "T", matcher.group(2));
6571 assertEquals(outputLines[4], "SUCCESS", matcher.group(3));
6572 assertEquals(outputLines[4], "aStem:aGroup2", matcher.group(4));
6573 assertEquals(outputLines[4], "0", matcher.group(5));
6574 subjectId = matcher.group(6);
6575 assertTrue(outputLines[4], GrouperClientUtils.equals("test.subject.2",
6576 subjectId)
6577 || GrouperClientUtils.equals("test.subject.3", subjectId));
6578
6579 matcher = pattern.matcher(outputLines[5]);
6580
6581 assertTrue(outputLines[5], matcher.matches());
6582
6583 assertEquals(outputLines[5], "1", matcher.group(1));
6584 assertEquals(outputLines[5], "T", matcher.group(2));
6585 assertEquals(outputLines[5], "SUCCESS", matcher.group(3));
6586 assertEquals(outputLines[5], "aStem:aGroup2", matcher.group(4));
6587 assertEquals(outputLines[5], "1", matcher.group(5));
6588 subjectId = matcher.group(6);
6589 assertTrue(outputLines[5], GrouperClientUtils.equals("test.subject.2",
6590 subjectId)
6591 || GrouperClientUtils.equals("test.subject.3", subjectId));
6592
6593
6594
6595
6596
6597 baos = new ByteArrayOutputStream();
6598 System.setOut(new PrintStream(baos));
6599
6600 GrouperClient.main(GrouperClientUtils.splitTrim(
6601 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=jdbc,g:gsa",
6602 " "));
6603
6604 System.out.flush();
6605 output = new String(baos.toByteArray());
6606
6607 System.setOut(systemOut);
6608
6609 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6610
6611 assertEquals(4, GrouperUtil.length(outputLines));
6612
6613 baos = new ByteArrayOutputStream();
6614 System.setOut(new PrintStream(baos));
6615
6616 GrouperClient.main(GrouperClientUtils.splitTrim(
6617 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=g:gsa",
6618 " "));
6619
6620 System.out.flush();
6621 output = new String(baos.toByteArray());
6622
6623 System.setOut(systemOut);
6624
6625 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6626
6627 assertEquals(0, GrouperUtil.length(outputLines));
6628
6629
6630
6631
6632
6633 baos = new ByteArrayOutputStream();
6634 System.setOut(new PrintStream(baos));
6635
6636 Group aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
6637 Group aGroup2 = GroupFinder.findByName(grouperSession, "aStem:aGroup2", true);
6638
6639 GrouperClient.main(GrouperClientUtils.splitTrim(
6640 "--operation=getMembersWs --groupUuids=" + aGroup.getUuid() + "," + aGroup2.getUuid(),
6641 " "));
6642
6643 System.out.flush();
6644 output = new String(baos.toByteArray());
6645
6646 System.setOut(systemOut);
6647
6648 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6649
6650 assertEquals(4, GrouperUtil.length(outputLines));
6651
6652
6653
6654
6655
6656 baos = new ByteArrayOutputStream();
6657 System.setOut(new PrintStream(baos));
6658
6659 GrouperClient.main(GrouperClientUtils.splitTrim(
6660 "--operation=getMembersWs --groupIdIndexes=" + aGroup.getIdIndex() + "," + aGroup2.getIdIndex(),
6661 " "));
6662
6663 System.out.flush();
6664 output = new String(baos.toByteArray());
6665
6666 System.setOut(systemOut);
6667
6668 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6669
6670 assertEquals(4, GrouperUtil.length(outputLines));
6671
6672
6673
6674
6675
6676 baos = new ByteArrayOutputStream();
6677 System.setOut(new PrintStream(baos));
6678
6679 GrouperClient
6680 .main(GrouperClientUtils
6681 .splitTrim(
6682 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=a,name --outputTemplate=${wsSubject.getAttributeValue(1)}$newline$",
6683 " "));
6684 System.out.flush();
6685 output = new String(baos.toByteArray());
6686
6687 System.setOut(systemOut);
6688
6689 outputLines = GrouperClientUtils.splitTrim(output, "\n");
6690
6691 Arrays.sort(outputLines);
6692
6693 assertEquals(outputLines[0], "my name is test.subject.0");
6694 assertEquals(outputLines[1], "my name is test.subject.1");
6695 assertEquals(outputLines[2], "my name is test.subject.2");
6696 assertEquals(outputLines[3], "my name is test.subject.3");
6697
6698
6699
6700
6701 baos = new ByteArrayOutputStream();
6702 System.setOut(new PrintStream(baos));
6703
6704 GrouperClient
6705 .main(GrouperClientUtils
6706 .splitTrim(
6707 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=Effective",
6708 " "));
6709 System.out.flush();
6710 output = new String(baos.toByteArray());
6711
6712 System.setOut(systemOut);
6713
6714 assertTrue(GrouperClientWs.mostRecentRequest,
6715 GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6716 assertTrue(GrouperClientWs.mostRecentRequest,
6717 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6718 assertTrue(GrouperClientWs.mostRecentRequest,
6719 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6720 assertTrue(GrouperClientWs.mostRecentRequest,
6721 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6722 assertTrue(GrouperClientWs.mostRecentRequest,
6723 !GrouperClientWs.mostRecentRequest.contains("params"));
6724 assertTrue(GrouperClientWs.mostRecentRequest,
6725 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6726 assertTrue(GrouperClientWs.mostRecentRequest,
6727 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6728
6729
6730
6731
6732 baos = new ByteArrayOutputStream();
6733 System.setOut(new PrintStream(baos));
6734
6735 GrouperClient
6736 .main(GrouperClientUtils
6737 .splitTrim(
6738 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=NonImmediate",
6739 " "));
6740 System.out.flush();
6741 output = new String(baos.toByteArray());
6742
6743 System.setOut(systemOut);
6744
6745 assertTrue(GrouperClientWs.mostRecentRequest,
6746 GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6747 assertTrue(GrouperClientWs.mostRecentRequest,
6748 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6749 assertTrue(GrouperClientWs.mostRecentRequest,
6750 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6751 assertTrue(GrouperClientWs.mostRecentRequest,
6752 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6753 assertTrue(GrouperClientWs.mostRecentRequest,
6754 !GrouperClientWs.mostRecentRequest.contains("params"));
6755 assertTrue(GrouperClientWs.mostRecentRequest,
6756 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6757 assertTrue(GrouperClientWs.mostRecentRequest,
6758 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6759
6760
6761
6762
6763 baos = new ByteArrayOutputStream();
6764 System.setOut(new PrintStream(baos));
6765
6766 GrouperClient
6767 .main(GrouperClientUtils
6768 .splitTrim(
6769 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeGroupDetail=true",
6770 " "));
6771 System.out.flush();
6772 output = new String(baos.toByteArray());
6773
6774 System.setOut(systemOut);
6775
6776 assertTrue(GrouperClientWs.mostRecentRequest,
6777 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6778 assertTrue(GrouperClientWs.mostRecentRequest,
6779 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6780 assertTrue(GrouperClientWs.mostRecentRequest,
6781 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6782 assertTrue(GrouperClientWs.mostRecentRequest,
6783 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6784 assertTrue(GrouperClientWs.mostRecentRequest,
6785 !GrouperClientWs.mostRecentRequest.contains("params"));
6786 assertTrue(GrouperClientWs.mostRecentRequest,
6787 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6788 assertTrue(GrouperClientWs.mostRecentRequest,
6789 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6790
6791
6792
6793
6794 baos = new ByteArrayOutputStream();
6795 System.setOut(new PrintStream(baos));
6796
6797 GrouperClient
6798 .main(GrouperClientUtils
6799 .splitTrim(
6800 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeSubjectDetail=true",
6801 " "));
6802 System.out.flush();
6803 output = new String(baos.toByteArray());
6804
6805 System.setOut(systemOut);
6806
6807 assertTrue(GrouperClientWs.mostRecentRequest,
6808 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6809 assertTrue(GrouperClientWs.mostRecentRequest,
6810 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6811 assertTrue(GrouperClientWs.mostRecentRequest,
6812 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6813 assertTrue(GrouperClientWs.mostRecentRequest,
6814 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6815 assertTrue(GrouperClientWs.mostRecentRequest,
6816 !GrouperClientWs.mostRecentRequest.contains("params"));
6817 assertTrue(GrouperClientWs.mostRecentRequest,
6818 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6819 assertTrue(GrouperClientWs.mostRecentRequest,
6820 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6821
6822
6823
6824
6825 baos = new ByteArrayOutputStream();
6826 System.setOut(new PrintStream(baos));
6827
6828 GrouperClient
6829 .main(GrouperClientUtils
6830 .splitTrim(
6831 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=name",
6832 " "));
6833 System.out.flush();
6834 output = new String(baos.toByteArray());
6835
6836 System.setOut(systemOut);
6837
6838 assertTrue(GrouperClientWs.mostRecentRequest,
6839 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6840 assertTrue(GrouperClientWs.mostRecentRequest,
6841 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6842 assertTrue(GrouperClientWs.mostRecentRequest,
6843 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6844 assertTrue(GrouperClientWs.mostRecentRequest,
6845 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6846 assertTrue(GrouperClientWs.mostRecentRequest,
6847 !GrouperClientWs.mostRecentRequest.contains("params"));
6848 assertTrue(GrouperClientWs.mostRecentRequest,
6849 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6850 assertTrue(GrouperClientWs.mostRecentRequest,
6851 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6852
6853
6854
6855
6856 baos = new ByteArrayOutputStream();
6857 System.setOut(new PrintStream(baos));
6858
6859 GrouperClient
6860 .main(GrouperClientUtils
6861 .splitTrim(
6862 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --paramName0=someParam --paramValue0=someValue",
6863 " "));
6864 System.out.flush();
6865 output = new String(baos.toByteArray());
6866
6867 System.setOut(systemOut);
6868
6869 assertTrue(GrouperClientWs.mostRecentRequest,
6870 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6871 assertTrue(GrouperClientWs.mostRecentRequest,
6872 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6873 assertTrue(GrouperClientWs.mostRecentRequest,
6874 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6875 assertTrue(GrouperClientWs.mostRecentRequest,
6876 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6877 assertTrue(GrouperClientWs.mostRecentRequest,
6878 GrouperClientWs.mostRecentRequest.contains("someParam")
6879 && GrouperClientWs.mostRecentRequest.toLowerCase().contains(
6880 "params")
6881 && GrouperClientWs.mostRecentRequest.contains("someValue"));
6882 assertTrue(GrouperClientWs.mostRecentRequest,
6883 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6884 assertTrue(GrouperClientWs.mostRecentRequest,
6885 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6886
6887
6888
6889
6890 baos = new ByteArrayOutputStream();
6891 System.setOut(new PrintStream(baos));
6892
6893 GrouperClient
6894 .main(GrouperClientUtils
6895 .splitTrim(
6896 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --fieldName=members",
6897 " "));
6898 System.out.flush();
6899 output = new String(baos.toByteArray());
6900
6901 System.setOut(systemOut);
6902
6903 assertTrue(GrouperClientWs.mostRecentRequest,
6904 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6905 assertTrue(GrouperClientWs.mostRecentRequest,
6906 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6907 assertTrue(GrouperClientWs.mostRecentRequest,
6908 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6909 assertTrue(GrouperClientWs.mostRecentRequest,
6910 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6911 assertTrue(GrouperClientWs.mostRecentRequest,
6912 !GrouperClientWs.mostRecentRequest.contains("params"));
6913 assertTrue(GrouperClientWs.mostRecentRequest,
6914 GrouperClientWs.mostRecentRequest.contains("fieldName")
6915 && GrouperClientWs.mostRecentRequest.contains("members"));
6916 assertTrue(GrouperClientWs.mostRecentRequest,
6917 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6918
6919
6920
6921
6922 baos = new ByteArrayOutputStream();
6923 System.setOut(new PrintStream(baos));
6924
6925 GrouperClient
6926 .main(GrouperClientUtils
6927 .splitTrim(
6928 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsSubjectId=GrouperSystem",
6929 " "));
6930 System.out.flush();
6931 output = new String(baos.toByteArray());
6932
6933 System.setOut(systemOut);
6934
6935 assertTrue(GrouperClientWs.mostRecentRequest,
6936 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6937 assertTrue(GrouperClientWs.mostRecentRequest,
6938 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6939 assertTrue(GrouperClientWs.mostRecentRequest,
6940 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6941 assertTrue(GrouperClientWs.mostRecentRequest,
6942 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6943 assertTrue(GrouperClientWs.mostRecentRequest,
6944 !GrouperClientWs.mostRecentRequest.contains("params"));
6945 assertTrue(GrouperClientWs.mostRecentRequest,
6946 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6947 assertTrue(GrouperClientWs.mostRecentRequest,
6948 GrouperClientWs.mostRecentRequest.contains("actAsSubject")
6949 && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
6950
6951
6952
6953
6954 baos = new ByteArrayOutputStream();
6955 System.setOut(new PrintStream(baos));
6956
6957 GrouperClient
6958 .main(GrouperClientUtils
6959 .splitTrim(
6960 "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsPennId=GrouperSystem",
6961 " "));
6962 System.out.flush();
6963 output = new String(baos.toByteArray());
6964
6965 System.setOut(systemOut);
6966
6967 assertTrue(GrouperClientWs.mostRecentRequest,
6968 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6969 assertTrue(GrouperClientWs.mostRecentRequest,
6970 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6971 assertTrue(GrouperClientWs.mostRecentRequest,
6972 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6973 assertTrue(GrouperClientWs.mostRecentRequest,
6974 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6975 assertTrue(GrouperClientWs.mostRecentRequest,
6976 !GrouperClientWs.mostRecentRequest.contains("params"));
6977 assertTrue(GrouperClientWs.mostRecentRequest,
6978 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6979 assertTrue(GrouperClientWs.mostRecentRequest,
6980 GrouperClientWs.mostRecentRequest.contains("actAsSubject")
6981 && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
6982
6983 } finally {
6984 System.setOut(systemOut);
6985 }
6986
6987 }
6988
6989
6990
6991
6992 public void testGetGroups2() throws Exception {
6993
6994
6995 @SuppressWarnings("unused")
6996 GrouperSession grouperSession = GrouperSession.startRootSession();
6997
6998 Subject subj = SubjectTestHelper.SUBJ0;
6999 Subject subj1 = SubjectTestHelper.SUBJ1;
7000 GrouperSession s = SessionHelper.getRootSession();
7001 Stem root = StemFinder.findRootStem(s);
7002 Stem edu = root.addChildStem("edu", "edu");
7003 Stem eduSub = edu.addChildStem("eduSub", "eduSub");
7004 Stem edu2 = root.addChildStem("edu2", "edu2");
7005 Group i2 = edu.addChildGroup("i2", "i2");
7006 Group i2sub = eduSub.addChildGroup("i2sub", "i2sub");
7007 Group edu2i2sub = edu2.addChildGroup("edu2i2sub", "edu2i2sub");
7008 Group comp1 = edu.addChildGroup("comp1", "comp1");
7009 Group compLeft = edu.addChildGroup("compLeft", "compRight");
7010 Group compRight = edu.addChildGroup("compRight", "compRight");
7011
7012 comp1.addCompositeMember(CompositeType.INTERSECTION, compLeft, compRight);
7013
7014 compLeft.addMember(subj);
7015 compRight.addMember(subj);
7016
7017 Group uofc = edu.addChildGroup("uofc", "uofc");
7018 GroupHelper.addMember(uofc, subj, "members");
7019 GroupHelper.addMember(i2, uofc.toSubject(), "members");
7020
7021 i2sub.addMember(subj1);
7022 edu2i2sub.addMember(subj1);
7023
7024
7025 String wsUserLabel = GrouperClientUtils.propertiesValue(
7026 "grouperClient.webService.user.label", true);
7027 String wsUserString = GrouperClientUtils.propertiesValue(
7028 "grouperClient.webService." + wsUserLabel, true);
7029 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
7030
7031 i2.grantPriv(wsUser, AccessPrivilege.READ, false);
7032 i2sub.grantPriv(wsUser, AccessPrivilege.READ, false);
7033 edu2i2sub.grantPriv(wsUser, AccessPrivilege.READ, false);
7034 comp1.grantPriv(wsUser, AccessPrivilege.READ, false);
7035 compLeft.grantPriv(wsUser, AccessPrivilege.READ, false);
7036 compRight.grantPriv(wsUser, AccessPrivilege.READ, false);
7037 uofc.grantPriv(wsUser, AccessPrivilege.READ, false);
7038
7039
7040 PrintStream systemOut = System.out;
7041
7042 ByteArrayOutputStream baos = new ByteArrayOutputStream();
7043 System.setOut(new PrintStream(baos));
7044
7045
7046
7047
7048
7049
7050
7051 GrouperClient.main(GrouperClientUtils.splitTrim(
7052 "--operation=getGroupsWs --subjectIds=test.subject.0 --memberFilter=Immediate --sortString=name",
7053 " "));
7054 System.out.flush();
7055 String output = new String(baos.toByteArray());
7056
7057 System.setOut(systemOut);
7058
7059 System.out.println(output);
7060
7061 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
7062
7063 assertEquals(3, outputLines.length);
7064
7065 Pattern pattern = Pattern
7066 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7067 Matcher matcher = pattern.matcher(outputLines[0]);
7068
7069 assertTrue(outputLines[0], matcher.matches());
7070
7071 assertEquals("0", matcher.group(1));
7072 assertEquals("SUCCESS", matcher.group(2));
7073 assertEquals("test.subject.0", matcher.group(3));
7074 assertEquals("0", matcher.group(4));
7075 assertEquals(matcher.group(5), compLeft.getName(), matcher.group(5));
7076
7077 matcher = pattern.matcher(outputLines[1]);
7078
7079 assertTrue(outputLines[1], matcher.matches());
7080
7081 assertEquals("0", matcher.group(1));
7082 assertEquals("SUCCESS", matcher.group(2));
7083 assertEquals("test.subject.0", matcher.group(3));
7084 assertEquals("1", matcher.group(4));
7085 assertEquals(matcher.group(5), compRight.getName(), matcher.group(5));
7086
7087 matcher = pattern.matcher(outputLines[2]);
7088
7089 assertTrue(outputLines[2], matcher.matches());
7090
7091 assertEquals("0", matcher.group(1));
7092 assertEquals("SUCCESS", matcher.group(2));
7093 assertEquals("test.subject.0", matcher.group(3));
7094 assertEquals("2", matcher.group(4));
7095 assertEquals(matcher.group(5), uofc.getName(), matcher.group(5));
7096
7097
7098
7099
7100
7101
7102
7103
7104 baos = new ByteArrayOutputStream();
7105 System.setOut(new PrintStream(baos));
7106
7107
7108 GrouperClient
7109 .main(GrouperClientUtils
7110 .splitTrim(
7111 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0 --memberFilter=NonImmediate --sortString=name",
7112 " "));
7113
7114 System.out.flush();
7115
7116 output = new String(baos.toByteArray());
7117
7118 System.setOut(systemOut);
7119
7120 System.out.println(output);
7121
7122 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7123
7124 assertEquals(2, outputLines.length);
7125
7126 pattern = Pattern
7127 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7128 matcher = pattern.matcher(outputLines[0]);
7129
7130 assertTrue(outputLines[0], matcher.matches());
7131
7132 assertEquals("0", matcher.group(1));
7133 assertEquals("SUCCESS", matcher.group(2));
7134 assertEquals("test.subject.0", matcher.group(3));
7135 assertEquals("0", matcher.group(4));
7136 assertEquals(matcher.group(5), comp1.getName(), matcher.group(5));
7137
7138 matcher = pattern.matcher(outputLines[1]);
7139
7140 assertTrue(outputLines[1], matcher.matches());
7141
7142 assertEquals("0", matcher.group(1));
7143 assertEquals("SUCCESS", matcher.group(2));
7144 assertEquals("test.subject.0", matcher.group(3));
7145 assertEquals("1", matcher.group(4));
7146 assertEquals(matcher.group(5), i2.getName(), matcher.group(5));
7147
7148
7149
7150
7151
7152 baos = new ByteArrayOutputStream();
7153 System.setOut(new PrintStream(baos));
7154
7155
7156 GrouperClient
7157 .main(GrouperClientUtils
7158 .splitTrim(
7159 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Effective",
7160 " "));
7161
7162 System.out.flush();
7163
7164 output = new String(baos.toByteArray());
7165
7166 System.setOut(systemOut);
7167
7168 System.out.println(output);
7169
7170 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7171
7172 assertEquals(0, GrouperClientUtils.length(outputLines));
7173
7174
7175
7176
7177
7178 baos = new ByteArrayOutputStream();
7179 System.setOut(new PrintStream(baos));
7180
7181
7182 GrouperClient
7183 .main(GrouperClientUtils
7184 .splitTrim(
7185 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --fieldName=members --enabled=T --scope=whatever",
7186 " "));
7187
7188 System.out.flush();
7189
7190 output = new String(baos.toByteArray());
7191
7192 System.setOut(systemOut);
7193
7194 System.out.println(output);
7195
7196 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7197
7198 assertEquals(0, GrouperClientUtils.length(outputLines));
7199
7200
7201
7202
7203
7204
7205 baos = new ByteArrayOutputStream();
7206 System.setOut(new PrintStream(baos));
7207
7208
7209 GrouperClient
7210 .main(GrouperClientUtils
7211 .splitTrim(
7212 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --scope=edu:eduSub",
7213 " "));
7214
7215 System.out.flush();
7216
7217 output = new String(baos.toByteArray());
7218
7219 System.setOut(systemOut);
7220
7221 System.out.println(output);
7222
7223 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7224
7225 assertEquals(1, outputLines.length);
7226
7227 pattern = Pattern
7228 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7229 matcher = pattern.matcher(outputLines[0]);
7230
7231 assertTrue(outputLines[0], matcher.matches());
7232
7233 assertEquals("0", matcher.group(1));
7234 assertEquals("SUCCESS", matcher.group(2));
7235 assertEquals("test.subject.1", matcher.group(3));
7236 assertEquals("0", matcher.group(4));
7237 assertEquals(matcher.group(5), i2sub.getName(), matcher.group(5));
7238
7239
7240
7241
7242
7243
7244 baos = new ByteArrayOutputStream();
7245 System.setOut(new PrintStream(baos));
7246
7247
7248 GrouperClient
7249 .main(GrouperClientUtils
7250 .splitTrim(
7251 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --scope=edu2",
7252 " "));
7253
7254 System.out.flush();
7255
7256 output = new String(baos.toByteArray());
7257
7258 System.setOut(systemOut);
7259
7260 System.out.println(output);
7261
7262 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7263
7264 assertEquals(1, outputLines.length);
7265
7266 pattern = Pattern
7267 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7268 matcher = pattern.matcher(outputLines[0]);
7269
7270 assertTrue(outputLines[0], matcher.matches());
7271
7272 assertEquals("0", matcher.group(1));
7273 assertEquals("SUCCESS", matcher.group(2));
7274 assertEquals("test.subject.1", matcher.group(3));
7275 assertEquals("0", matcher.group(4));
7276 assertEquals(matcher.group(5), edu2i2sub.getName(), matcher.group(5));
7277
7278
7279
7280
7281
7282 baos = new ByteArrayOutputStream();
7283 System.setOut(new PrintStream(baos));
7284
7285
7286 GrouperClient
7287 .main(GrouperClientUtils
7288 .splitTrim(
7289 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --fieldName=members --enabled=F --scope=edu2",
7290 " "));
7291
7292 System.out.flush();
7293
7294 output = new String(baos.toByteArray());
7295
7296 System.setOut(systemOut);
7297
7298 System.out.println(output);
7299
7300 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7301
7302 assertEquals(0, GrouperClientUtils.length(outputLines));
7303
7304
7305
7306
7307
7308
7309
7310
7311
7312
7313 baos = new ByteArrayOutputStream();
7314 System.setOut(new PrintStream(baos));
7315
7316
7317 try {
7318 GrouperClient
7319 .main(GrouperClientUtils
7320 .splitTrim(
7321 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stem=" + edu.getName(),
7322 " "));
7323 fail("Need stemScope");
7324 } catch (Exception e) {
7325
7326 } finally {
7327 System.out.flush();
7328
7329 output = new String(baos.toByteArray());
7330
7331 System.setOut(systemOut);
7332
7333 System.out.println(output);
7334 }
7335
7336
7337
7338
7339
7340 baos = new ByteArrayOutputStream();
7341 System.setOut(new PrintStream(baos));
7342
7343
7344 GrouperClient
7345 .main(GrouperClientUtils
7346 .splitTrim(
7347 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu.getName() + " --stemScope=ONE_LEVEL",
7348 " "));
7349
7350 System.out.flush();
7351
7352 output = new String(baos.toByteArray());
7353
7354 System.setOut(systemOut);
7355
7356 System.out.println(output);
7357
7358 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7359
7360 assertEquals(0, GrouperClientUtils.length(outputLines));
7361
7362
7363
7364
7365
7366
7367 baos = new ByteArrayOutputStream();
7368 System.setOut(new PrintStream(baos));
7369
7370
7371 GrouperClient
7372 .main(GrouperClientUtils
7373 .splitTrim(
7374 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu2.getName() + " --stemScope=ONE_LEVEL",
7375 " "));
7376
7377 System.out.flush();
7378
7379 output = new String(baos.toByteArray());
7380
7381 System.setOut(systemOut);
7382
7383 System.out.println(output);
7384
7385 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7386
7387 assertEquals(1, outputLines.length);
7388
7389 pattern = Pattern
7390 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7391 matcher = pattern.matcher(outputLines[0]);
7392
7393 assertTrue(outputLines[0], matcher.matches());
7394
7395 assertEquals("0", matcher.group(1));
7396 assertEquals("SUCCESS", matcher.group(2));
7397 assertEquals("test.subject.1", matcher.group(3));
7398 assertEquals("0", matcher.group(4));
7399 assertEquals(matcher.group(5), edu2i2sub.getName(), matcher.group(5));
7400
7401
7402
7403
7404
7405
7406 baos = new ByteArrayOutputStream();
7407 System.setOut(new PrintStream(baos));
7408
7409
7410 GrouperClient
7411 .main(GrouperClientUtils
7412 .splitTrim(
7413 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu.getName() + " --stemScope=ALL_IN_SUBTREE",
7414 " "));
7415
7416 System.out.flush();
7417
7418 output = new String(baos.toByteArray());
7419
7420 System.setOut(systemOut);
7421
7422 System.out.println(output);
7423
7424 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7425
7426 assertEquals(1, outputLines.length);
7427
7428 pattern = Pattern
7429 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7430 matcher = pattern.matcher(outputLines[0]);
7431
7432 assertTrue(outputLines[0], matcher.matches());
7433
7434 assertEquals("0", matcher.group(1));
7435 assertEquals("SUCCESS", matcher.group(2));
7436 assertEquals("test.subject.1", matcher.group(3));
7437 assertEquals("0", matcher.group(4));
7438 assertEquals(matcher.group(5), i2sub.getName(), matcher.group(5));
7439
7440
7441
7442
7443
7444
7445 baos = new ByteArrayOutputStream();
7446 System.setOut(new PrintStream(baos));
7447
7448
7449 GrouperClient
7450 .main(GrouperClientUtils
7451 .splitTrim(
7452 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu2.getName() + " --stemScope=ALL_IN_SUBTREE",
7453 " "));
7454
7455 System.out.flush();
7456
7457 output = new String(baos.toByteArray());
7458
7459 System.setOut(systemOut);
7460
7461 System.out.println(output);
7462
7463 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7464
7465 assertEquals(1, outputLines.length);
7466
7467 pattern = Pattern
7468 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7469 matcher = pattern.matcher(outputLines[0]);
7470
7471 assertTrue(outputLines[0], matcher.matches());
7472
7473 assertEquals("0", matcher.group(1));
7474 assertEquals("SUCCESS", matcher.group(2));
7475 assertEquals("test.subject.1", matcher.group(3));
7476 assertEquals("0", matcher.group(4));
7477 assertEquals(matcher.group(5), edu2i2sub.getName(), matcher.group(5));
7478
7479
7480
7481
7482
7483
7484
7485 baos = new ByteArrayOutputStream();
7486 System.setOut(new PrintStream(baos));
7487
7488
7489 GrouperClient
7490 .main(GrouperClientUtils
7491 .splitTrim(
7492 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0 --memberFilter=Immediate --pageSize=1 --pageNumber=1 --sortString=name",
7493 " "));
7494
7495 System.out.flush();
7496
7497 output = new String(baos.toByteArray());
7498
7499 System.setOut(systemOut);
7500
7501 System.out.println(output);
7502
7503 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7504
7505 assertEquals(1, outputLines.length);
7506
7507 pattern = Pattern
7508 .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7509 matcher = pattern.matcher(outputLines[0]);
7510
7511 assertTrue(outputLines[0], matcher.matches());
7512
7513 assertEquals("0", matcher.group(1));
7514 assertEquals("SUCCESS", matcher.group(2));
7515 assertEquals("test.subject.0", matcher.group(3));
7516 assertEquals("0", matcher.group(4));
7517 assertEquals(matcher.group(5), compLeft.getName(), matcher.group(5));
7518
7519
7520
7521
7522
7523
7524
7525
7526
7527
7528
7529 baos = new ByteArrayOutputStream();
7530 System.setOut(new PrintStream(baos));
7531
7532 try {
7533
7534 GrouperClient
7535 .main(GrouperClientUtils
7536 .splitTrim(
7537 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0 --memberFilter=Immediate --pageSize=1 --pageNumber=1 --sortString=doesntExist",
7538 " "));
7539 fail("Column doesnt exist");
7540 } catch (Exception e) {
7541
7542 } finally {
7543 System.out.flush();
7544
7545 output = new String(baos.toByteArray());
7546
7547 System.setOut(systemOut);
7548
7549 System.out.println(output);
7550 }
7551
7552 }
7553
7554
7555
7556
7557
7558 public void testGetMembershipsForService() throws Exception {
7559
7560 GrouperSession grouperSession = GrouperSession.startRootSession();
7561
7562 AttributeDefName jiraService = null;
7563 AttributeDefName confluenceService = null;
7564 AttributeDefName directoryService = null;
7565
7566
7567 AttributeDef jiraServiceDef = new AttributeDefSave(grouperSession)
7568 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
7569 .assignName("apps:jira:jiraServiceDefinition").assignToStem(true).save();
7570
7571 jiraService = new AttributeDefNameSave(grouperSession, jiraServiceDef)
7572 .assignCreateParentStemsIfNotExist(true)
7573 .assignName("apps:jira:jiraService").assignDisplayExtension("Central IT production Jira issue tracker").save();
7574
7575
7576 Group jiraGroup = new GroupSave(grouperSession)
7577 .assignName("apps:jira:groups:admins").assignCreateParentStemsIfNotExist(true).save();
7578
7579 jiraGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ, false);
7580 jiraGroup.revokePriv(grouperSession.getSubject(), AccessPrivilege.ADMIN, false);
7581 jiraGroup.grantPriv(SubjectTestHelper.SUBJ5, AccessPrivilege.READ, false);
7582 jiraGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.ADMIN, false);
7583
7584 jiraGroup.addMember(SubjectTestHelper.SUBJ0);
7585 jiraGroup.addMember(SubjectTestHelper.SUBJ1);
7586
7587
7588 Stem jiraStem = StemFinder.findByUuid(grouperSession, jiraGroup.getStemId(), true);
7589 jiraStem.getAttributeDelegate().assignAttribute(jiraService);
7590
7591 AttributeDef confluenceServiceDef = new AttributeDefSave(grouperSession)
7592 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
7593 .assignName("apps:confluence:confluenceServiceDefinition").assignToStem(true).save();
7594
7595 confluenceService = new AttributeDefNameSave(grouperSession, confluenceServiceDef)
7596 .assignCreateParentStemsIfNotExist(true)
7597 .assignName("apps:confluence:confluenceService").assignDisplayExtension("Central IT production Confluence wiki").save();
7598
7599 Group confluenceGroup = new GroupSave(grouperSession)
7600 .assignName("apps:confluence:editors").assignCreateParentStemsIfNotExist(true).save();
7601
7602 confluenceGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
7603 confluenceGroup.revokePriv(grouperSession.getSubject(), AccessPrivilege.ADMIN);
7604 confluenceGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.READ);
7605 confluenceGroup.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.ADMIN);
7606 confluenceGroup.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.UPDATE);
7607
7608 confluenceGroup.addMember(SubjectTestHelper.SUBJ1);
7609 confluenceGroup.addMember(SubjectTestHelper.SUBJ2);
7610
7611
7612 Stem confluenceFolder = StemFinder.findByName(grouperSession, "apps:confluence", true);
7613 confluenceFolder.getAttributeDelegate().assignAttribute(confluenceService);
7614
7615 AttributeDef directoryServiceDef = new AttributeDefSave(grouperSession)
7616 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
7617 .assignName("apps:directory:directoryServiceDefinition").assignToStem(true).save();
7618
7619 directoryService = new AttributeDefNameSave(grouperSession, directoryServiceDef)
7620 .assignCreateParentStemsIfNotExist(true)
7621 .assignName("apps:directory:directoryService").assignDisplayExtension("MySchool directory").save();
7622
7623 Group directoryGroup = new GroupSave(grouperSession)
7624 .assignName("apps:directory:users").assignCreateParentStemsIfNotExist(true).save();
7625
7626 directoryGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
7627 directoryGroup.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.READ);
7628 directoryGroup.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.READ);
7629 directoryGroup.addMember(SubjectTestHelper.SUBJ2);
7630 directoryGroup.addMember(SubjectTestHelper.SUBJ3);
7631
7632
7633 Stem directoryFolder = StemFinder.findByName(grouperSession, "apps:directory", true);
7634 directoryFolder.getAttributeDelegate().assignAttribute(directoryService);
7635
7636 PrintStream systemOut = System.out;
7637
7638 ByteArrayOutputStream baos = new ByteArrayOutputStream();
7639 System.setOut(new PrintStream(baos));
7640
7641 try {
7642
7643
7644
7645 GrouperClient.main(GrouperClientUtils.splitTrim(
7646 "--operation=getMembershipsWs --serviceId=" + jiraService.getId() + " --serviceRole=user",
7647 " "));
7648 System.out.flush();
7649 String output = new String(baos.toByteArray());
7650
7651 System.setOut(systemOut);
7652
7653 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
7654
7655 assertEquals(2, GrouperUtil.length(outputLines));
7656
7657
7658
7659 Pattern pattern = Pattern
7660 .compile("^Index: (\\d+)\\: group\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
7661 String outputLine = outputLines[0];
7662
7663 Matcher matcher = pattern.matcher(outputLines[0]);
7664
7665 assertTrue(outputLine, matcher.matches());
7666 assertEquals(outputLine, "0", matcher.group(1));
7667 assertEquals(outputLine, "apps:jira:groups:admins", matcher.group(2));
7668 assertEquals(outputLine, "test.subject.0", matcher.group(3));
7669 assertEquals(outputLine, "members", matcher.group(4));
7670 assertEquals(outputLine, "immediate", matcher.group(5));
7671 assertEquals(outputLine, "T", matcher.group(6));
7672
7673 outputLine = outputLines[1];
7674
7675 matcher = pattern.matcher(outputLine);
7676
7677 assertTrue(outputLine, matcher.matches());
7678
7679 assertEquals(outputLine, "1", matcher.group(1));
7680 assertEquals(outputLine, "apps:jira:groups:admins", matcher.group(2));
7681 assertEquals(outputLine, "test.subject.1", matcher.group(3));
7682 assertEquals(outputLine, "members", matcher.group(4));
7683 assertEquals(outputLine, "immediate", matcher.group(5));
7684 assertEquals(outputLine, "T", matcher.group(6));
7685
7686 assertTrue(GrouperClientWs.mostRecentRequest,
7687 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
7688 assertTrue(GrouperClientWs.mostRecentRequest,
7689 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
7690 assertTrue(GrouperClientWs.mostRecentRequest,
7691 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
7692 assertTrue(GrouperClientWs.mostRecentRequest,
7693 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
7694 assertTrue(GrouperClientWs.mostRecentRequest,
7695 !GrouperClientWs.mostRecentRequest.contains("params"));
7696 assertTrue(GrouperClientWs.mostRecentRequest,
7697 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
7698 assertTrue(GrouperClientWs.mostRecentRequest,
7699 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
7700 assertTrue(GrouperClientWs.mostRecentRequest,
7701 GrouperClientWs.mostRecentRequest.contains("serviceRole"));
7702 assertTrue(GrouperClientWs.mostRecentRequest,
7703 GrouperClientWs.mostRecentRequest.contains("<serviceLookup><uuid>"));
7704 assertTrue(GrouperClientWs.mostRecentRequest,
7705 !GrouperClientWs.mostRecentRequest.contains("<serviceLookup><name>"));
7706
7707
7708
7709 baos = new ByteArrayOutputStream();
7710 System.setOut(new PrintStream(baos));
7711
7712 GrouperClient.main(GrouperClientUtils.splitTrim(
7713 "--operation=getMembershipsWs --serviceName=" + confluenceService.getName() + " --serviceRole=admin",
7714 " "));
7715 System.out.flush();
7716 output = new String(baos.toByteArray());
7717
7718 System.setOut(systemOut);
7719
7720 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7721
7722 assertEquals(2, GrouperUtil.length(outputLines));
7723
7724
7725
7726 pattern = Pattern
7727 .compile("^Index: (\\d+)\\: group\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
7728 outputLine = outputLines[0];
7729
7730 matcher = pattern.matcher(outputLines[0]);
7731
7732 assertTrue(outputLine, matcher.matches());
7733 assertEquals(outputLine, "0", matcher.group(1));
7734 assertEquals(outputLine, "apps:confluence:editors", matcher.group(2));
7735 assertEquals(outputLine, "test.subject.7", matcher.group(3));
7736 assertEquals(outputLine, "admins", matcher.group(4));
7737 assertEquals(outputLine, "immediate", matcher.group(5));
7738 assertEquals(outputLine, "T", matcher.group(6));
7739
7740 matcher = pattern.matcher(outputLines[1]);
7741
7742 assertTrue(outputLine, matcher.matches());
7743 assertEquals(outputLine, "1", matcher.group(1));
7744 assertEquals(outputLine, "apps:confluence:editors", matcher.group(2));
7745 assertEquals(outputLine, "test.subject.8", matcher.group(3));
7746 assertEquals(outputLine, "updaters", matcher.group(4));
7747 assertEquals(outputLine, "immediate", matcher.group(5));
7748 assertEquals(outputLine, "T", matcher.group(6));
7749
7750
7751 assertTrue(GrouperClientWs.mostRecentRequest,
7752 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
7753 assertTrue(GrouperClientWs.mostRecentRequest,
7754 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
7755 assertTrue(GrouperClientWs.mostRecentRequest,
7756 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
7757 assertTrue(GrouperClientWs.mostRecentRequest,
7758 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
7759 assertTrue(GrouperClientWs.mostRecentRequest,
7760 !GrouperClientWs.mostRecentRequest.contains("params"));
7761 assertTrue(GrouperClientWs.mostRecentRequest,
7762 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
7763 assertTrue(GrouperClientWs.mostRecentRequest,
7764 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
7765 assertTrue(GrouperClientWs.mostRecentRequest,
7766 GrouperClientWs.mostRecentRequest.contains("serviceRole"));
7767 assertTrue(GrouperClientWs.mostRecentRequest,
7768 GrouperClientWs.mostRecentRequest.contains("<serviceLookup><name>"));
7769 assertTrue(GrouperClientWs.mostRecentRequest,
7770 !GrouperClientWs.mostRecentRequest.contains("<serviceLookup><uuid>"));
7771
7772 } finally {
7773 System.setOut(systemOut);
7774 }
7775
7776 }
7777
7778
7779
7780
7781 public void testGetMemberships() throws Exception {
7782
7783
7784 GrouperSession grouperSession = GrouperSession.startRootSession();
7785 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
7786 "aStem:aGroup", "aGroup", null, null, true);
7787 Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
7788 "aStem:aGroup2", "aGroup2", null, null, true);
7789
7790 Stem stem = new StemSave(grouperSession).assignName("aStem1").assignCreateParentStemsIfNotExist(true).save();
7791 Stem stem2 = new StemSave(grouperSession).assignName("aStem2").assignCreateParentStemsIfNotExist(true).save();
7792
7793 AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem1:attributeDef1").assignCreateParentStemsIfNotExist(true).save();
7794 AttributeDef attributeDef2 = new AttributeDefSave(grouperSession).assignName("aStem2:attributeDef2").assignCreateParentStemsIfNotExist(true).save();
7795
7796
7797 String wsUserLabel = GrouperClientUtils.propertiesValue(
7798 "grouperClient.webService.user.label", true);
7799 String wsUserString = GrouperClientUtils.propertiesValue(
7800 "grouperClient.webService." + wsUserLabel, true);
7801 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
7802
7803 group.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
7804 group2.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
7805 stem.grantPriv(wsUser, NamingPrivilege.STEM, false);
7806 stem2.grantPriv(wsUser, NamingPrivilege.STEM, false);
7807 attributeDef.getPrivilegeDelegate().grantPriv(wsUser, AttributeDefPrivilege.ATTR_ADMIN, false);
7808 attributeDef2.getPrivilegeDelegate().grantPriv(wsUser, AttributeDefPrivilege.ATTR_ADMIN, false);
7809
7810
7811 group.addMember(SubjectTestHelper.SUBJ0, false);
7812 group.addMember(SubjectTestHelper.SUBJ1, false);
7813 group2.addMember(SubjectTestHelper.SUBJ2, false);
7814 group2.addMember(SubjectTestHelper.SUBJ3, false);
7815
7816 group.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.UPDATE, false);
7817 group.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN, false);
7818 group2.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.UPDATE, false);
7819 group2.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN, false);
7820
7821 stem.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.CREATE, false);
7822 stem.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.STEM, false);
7823 stem2.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.CREATE, false);
7824 stem2.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.STEM, false);
7825
7826 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
7827 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
7828 attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
7829 attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
7830
7831 GrouperSession.stopQuietly(grouperSession);
7832 grouperSession = GrouperSession.start(wsUser);
7833
7834 Set<Object[]> results = new MembershipFinder().addSubject(SubjectTestHelper.SUBJ7)
7835 .addSubject(SubjectTestHelper.SUBJ8).assignFieldType(FieldType.ACCESS).findMembershipsMembers();
7836
7837 assertEquals(GrouperUtil.toStringForLog(results), 4, GrouperUtil.length(results));
7838
7839 GrouperSession.stopQuietly(grouperSession);
7840 grouperSession = GrouperSession.startRootSession();
7841
7842
7843 PrintStream systemOut = System.out;
7844
7845 ByteArrayOutputStream baos = new ByteArrayOutputStream();
7846 System.setOut(new PrintStream(baos));
7847
7848 try {
7849
7850 GrouperClient.main(GrouperClientUtils.splitTrim(
7851 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2",
7852 " "));
7853 System.out.flush();
7854 String output = new String(baos.toByteArray());
7855
7856 System.setOut(systemOut);
7857
7858 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
7859
7860
7861
7862
7863 Pattern pattern = Pattern
7864 .compile("^Index: (\\d+)\\: group\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
7865 String outputLine = outputLines[0];
7866
7867 Matcher matcher = pattern.matcher(outputLines[0]);
7868
7869 assertTrue(outputLine, matcher.matches());
7870 assertEquals(outputLine, "0", matcher.group(1));
7871 assertEquals(outputLine, "aStem:aGroup", matcher.group(2));
7872 assertEquals(outputLine, "test.subject.0", matcher.group(3));
7873 assertEquals(outputLine, "members", matcher.group(4));
7874 assertEquals(outputLine, "immediate", matcher.group(5));
7875 assertEquals(outputLine, "T", matcher.group(6));
7876
7877 outputLine = outputLines[1];
7878
7879 matcher = pattern.matcher(outputLine);
7880
7881 assertTrue(outputLine, matcher.matches());
7882
7883 assertEquals(outputLine, "1", matcher.group(1));
7884 assertEquals(outputLine, "aStem:aGroup", matcher.group(2));
7885 assertEquals(outputLine, "test.subject.1", matcher.group(3));
7886 assertEquals(outputLine, "members", matcher.group(4));
7887 assertEquals(outputLine, "immediate", matcher.group(5));
7888 assertEquals(outputLine, "T", matcher.group(6));
7889
7890 outputLine = outputLines[2];
7891
7892 matcher = pattern.matcher(outputLine);
7893
7894 assertTrue(outputLine, matcher.matches());
7895
7896 assertEquals(outputLine, "2", matcher.group(1));
7897 assertEquals(outputLine, "aStem:aGroup2", matcher.group(2));
7898 assertEquals(outputLine, "test.subject.2", matcher.group(3));
7899 assertEquals(outputLine, "members", matcher.group(4));
7900 assertEquals(outputLine, "immediate", matcher.group(5));
7901 assertEquals(outputLine, "T", matcher.group(6));
7902
7903 outputLine = outputLines[3];
7904
7905 matcher = pattern.matcher(outputLine);
7906
7907 assertTrue(outputLine, matcher.matches());
7908
7909 assertEquals(outputLine, "3", matcher.group(1));
7910 assertEquals(outputLine, "aStem:aGroup2", matcher.group(2));
7911 assertEquals(outputLine, "test.subject.3", matcher.group(3));
7912 assertEquals(outputLine, "members", matcher.group(4));
7913 assertEquals(outputLine, "immediate", matcher.group(5));
7914 assertEquals(outputLine, "T", matcher.group(6));
7915
7916 assertTrue(GrouperClientWs.mostRecentRequest,
7917 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
7918 assertTrue(GrouperClientWs.mostRecentRequest,
7919 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
7920 assertTrue(GrouperClientWs.mostRecentRequest,
7921 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
7922 assertTrue(GrouperClientWs.mostRecentRequest,
7923 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
7924 assertTrue(GrouperClientWs.mostRecentRequest,
7925 !GrouperClientWs.mostRecentRequest.contains("params"));
7926 assertTrue(GrouperClientWs.mostRecentRequest,
7927 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
7928 assertTrue(GrouperClientWs.mostRecentRequest,
7929 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
7930 assertTrue(GrouperClientWs.mostRecentRequest,
7931 !GrouperClientWs.mostRecentRequest.contains("serviceRole"));
7932 assertTrue(GrouperClientWs.mostRecentRequest,
7933 !GrouperClientWs.mostRecentRequest.contains("<serviceLookup><uuid>"));
7934
7935
7936
7937
7938 baos = new ByteArrayOutputStream();
7939 System.setOut(new PrintStream(baos));
7940
7941 GrouperClient.main(GrouperClientUtils.splitTrim(
7942 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=jdbc,g:gsa",
7943 " "));
7944
7945 System.out.flush();
7946 output = new String(baos.toByteArray());
7947
7948 System.setOut(systemOut);
7949
7950 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7951
7952 assertEquals(4, GrouperUtil.length(outputLines));
7953
7954
7955
7956
7957 baos = new ByteArrayOutputStream();
7958 System.setOut(new PrintStream(baos));
7959
7960 GrouperClient.main(GrouperClientUtils.splitTrim(
7961 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=g:gsa",
7962 " "));
7963
7964 System.out.flush();
7965 output = new String(baos.toByteArray());
7966
7967 System.setOut(systemOut);
7968
7969 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7970
7971 assertEquals(0, GrouperUtil.length(outputLines));
7972
7973
7974
7975
7976
7977 baos = new ByteArrayOutputStream();
7978 System.setOut(new PrintStream(baos));
7979
7980 Group aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
7981 Group aGroup2 = GroupFinder.findByName(grouperSession, "aStem:aGroup2", true);
7982
7983 GrouperClient.main(GrouperClientUtils.splitTrim(
7984 "--operation=getMembershipsWs --groupUuids=" + aGroup.getUuid() + "," + aGroup2.getUuid(),
7985 " "));
7986
7987 System.out.flush();
7988 output = new String(baos.toByteArray());
7989
7990 System.setOut(systemOut);
7991
7992 outputLines = GrouperClientUtils.splitTrim(output, "\n");
7993
7994 assertEquals(4, GrouperUtil.length(outputLines));
7995
7996
7997
7998
7999 baos = new ByteArrayOutputStream();
8000 System.setOut(new PrintStream(baos));
8001
8002 aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
8003 aGroup2 = GroupFinder.findByName(grouperSession, "aStem:aGroup2", true);
8004 Stem aStem = StemFinder.findByName(grouperSession, "aStem", true);
8005
8006 GrouperClient.main(GrouperClientUtils.splitTrim(
8007 "--operation=getMembershipsWs --groupIdIndexes=" + aGroup.getIdIndex() + "," + aGroup2.getIdIndex(),
8008 " "));
8009
8010 System.out.flush();
8011 output = new String(baos.toByteArray());
8012
8013 System.setOut(systemOut);
8014
8015 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8016
8017 assertEquals(4, GrouperUtil.length(outputLines));
8018
8019
8020
8021
8022
8023 baos = new ByteArrayOutputStream();
8024 System.setOut(new PrintStream(baos));
8025
8026 GrouperClient
8027 .main(GrouperClientUtils
8028 .splitTrim(
8029 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=a,name --outputTemplate=${wsSubject.getAttributeValue(1)}$newline$",
8030 " "));
8031 System.out.flush();
8032 output = new String(baos.toByteArray());
8033
8034 System.setOut(systemOut);
8035
8036 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8037
8038 Arrays.sort(outputLines);
8039
8040 assertEquals(outputLines[0], "my name is test.subject.0");
8041 assertEquals(outputLines[1], "my name is test.subject.1");
8042 assertEquals(outputLines[2], "my name is test.subject.2");
8043 assertEquals(outputLines[3], "my name is test.subject.3");
8044
8045
8046
8047
8048 baos = new ByteArrayOutputStream();
8049 System.setOut(new PrintStream(baos));
8050
8051 GrouperClient
8052 .main(GrouperClientUtils
8053 .splitTrim(
8054 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=Effective",
8055 " "));
8056 System.out.flush();
8057 output = new String(baos.toByteArray());
8058
8059 System.setOut(systemOut);
8060
8061 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8062
8063 assertEquals(0, GrouperUtil.length(outputLines));
8064
8065 assertTrue(GrouperClientWs.mostRecentRequest,
8066 GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8067 assertTrue(GrouperClientWs.mostRecentRequest,
8068 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8069 assertTrue(GrouperClientWs.mostRecentRequest,
8070 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8071 assertTrue(GrouperClientWs.mostRecentRequest,
8072 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8073 assertTrue(GrouperClientWs.mostRecentRequest,
8074 !GrouperClientWs.mostRecentRequest.contains("params"));
8075 assertTrue(GrouperClientWs.mostRecentRequest,
8076 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8077 assertTrue(GrouperClientWs.mostRecentRequest,
8078 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8079
8080
8081
8082
8083 baos = new ByteArrayOutputStream();
8084 System.setOut(new PrintStream(baos));
8085
8086 GrouperClient
8087 .main(GrouperClientUtils
8088 .splitTrim(
8089 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=NonImmediate",
8090 " "));
8091 System.out.flush();
8092 output = new String(baos.toByteArray());
8093
8094 System.setOut(systemOut);
8095
8096 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8097
8098 assertEquals(0, GrouperUtil.length(outputLines));
8099
8100 assertTrue(GrouperClientWs.mostRecentRequest,
8101 GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8102 assertTrue(GrouperClientWs.mostRecentRequest,
8103 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8104 assertTrue(GrouperClientWs.mostRecentRequest,
8105 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8106 assertTrue(GrouperClientWs.mostRecentRequest,
8107 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8108 assertTrue(GrouperClientWs.mostRecentRequest,
8109 !GrouperClientWs.mostRecentRequest.contains("params"));
8110 assertTrue(GrouperClientWs.mostRecentRequest,
8111 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8112 assertTrue(GrouperClientWs.mostRecentRequest,
8113 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8114
8115
8116
8117
8118 baos = new ByteArrayOutputStream();
8119 System.setOut(new PrintStream(baos));
8120
8121 GrouperClient
8122 .main(GrouperClientUtils
8123 .splitTrim(
8124 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeGroupDetail=true",
8125 " "));
8126 System.out.flush();
8127 output = new String(baos.toByteArray());
8128
8129 System.setOut(systemOut);
8130
8131 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8132
8133 assertEquals(4, GrouperUtil.length(outputLines));
8134
8135 assertTrue(GrouperClientWs.mostRecentRequest,
8136 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8137 assertTrue(GrouperClientWs.mostRecentRequest,
8138 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8139 assertTrue(GrouperClientWs.mostRecentRequest,
8140 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8141 assertTrue(GrouperClientWs.mostRecentRequest,
8142 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8143 assertTrue(GrouperClientWs.mostRecentRequest,
8144 !GrouperClientWs.mostRecentRequest.contains("params"));
8145 assertTrue(GrouperClientWs.mostRecentRequest,
8146 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8147 assertTrue(GrouperClientWs.mostRecentRequest,
8148 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8149
8150
8151
8152
8153 baos = new ByteArrayOutputStream();
8154 System.setOut(new PrintStream(baos));
8155
8156 GrouperClient
8157 .main(GrouperClientUtils
8158 .splitTrim(
8159 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeSubjectDetail=true",
8160 " "));
8161 System.out.flush();
8162 output = new String(baos.toByteArray());
8163
8164 System.setOut(systemOut);
8165
8166 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8167
8168 assertEquals(4, GrouperUtil.length(outputLines));
8169
8170 assertTrue(GrouperClientWs.mostRecentRequest,
8171 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8172 assertTrue(GrouperClientWs.mostRecentRequest,
8173 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8174 assertTrue(GrouperClientWs.mostRecentRequest,
8175 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8176 assertTrue(GrouperClientWs.mostRecentRequest,
8177 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8178 assertTrue(GrouperClientWs.mostRecentRequest,
8179 !GrouperClientWs.mostRecentRequest.contains("params"));
8180 assertTrue(GrouperClientWs.mostRecentRequest,
8181 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8182 assertTrue(GrouperClientWs.mostRecentRequest,
8183 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8184
8185
8186
8187
8188 baos = new ByteArrayOutputStream();
8189 System.setOut(new PrintStream(baos));
8190
8191 GrouperClient
8192 .main(GrouperClientUtils
8193 .splitTrim(
8194 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=name",
8195 " "));
8196 System.out.flush();
8197 output = new String(baos.toByteArray());
8198
8199 System.setOut(systemOut);
8200
8201 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8202
8203 assertEquals(4, GrouperUtil.length(outputLines));
8204
8205 assertTrue(GrouperClientWs.mostRecentRequest,
8206 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8207 assertTrue(GrouperClientWs.mostRecentRequest,
8208 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8209 assertTrue(GrouperClientWs.mostRecentRequest,
8210 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8211 assertTrue(GrouperClientWs.mostRecentRequest,
8212 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8213 assertTrue(GrouperClientWs.mostRecentRequest,
8214 !GrouperClientWs.mostRecentRequest.contains("params"));
8215 assertTrue(GrouperClientWs.mostRecentRequest,
8216 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8217 assertTrue(GrouperClientWs.mostRecentRequest,
8218 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8219
8220
8221
8222
8223 baos = new ByteArrayOutputStream();
8224 System.setOut(new PrintStream(baos));
8225
8226 GrouperClient
8227 .main(GrouperClientUtils
8228 .splitTrim(
8229 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --paramName0=someParam --paramValue0=someValue",
8230 " "));
8231 System.out.flush();
8232 output = new String(baos.toByteArray());
8233
8234 System.setOut(systemOut);
8235
8236 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8237
8238 assertEquals(4, GrouperUtil.length(outputLines));
8239
8240 assertTrue(GrouperClientWs.mostRecentRequest,
8241 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8242 assertTrue(GrouperClientWs.mostRecentRequest,
8243 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8244 assertTrue(GrouperClientWs.mostRecentRequest,
8245 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8246 assertTrue(GrouperClientWs.mostRecentRequest,
8247 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8248 assertTrue(GrouperClientWs.mostRecentRequest,
8249 GrouperClientWs.mostRecentRequest.contains("someParam")
8250 && GrouperClientWs.mostRecentRequest.toLowerCase().contains(
8251 "params")
8252 && GrouperClientWs.mostRecentRequest.contains("someValue"));
8253 assertTrue(GrouperClientWs.mostRecentRequest,
8254 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8255 assertTrue(GrouperClientWs.mostRecentRequest,
8256 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8257
8258
8259
8260
8261 baos = new ByteArrayOutputStream();
8262 System.setOut(new PrintStream(baos));
8263
8264 GrouperClient
8265 .main(GrouperClientUtils
8266 .splitTrim(
8267 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --fieldName=members",
8268 " "));
8269 System.out.flush();
8270 output = new String(baos.toByteArray());
8271
8272 System.setOut(systemOut);
8273
8274 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8275
8276 assertEquals(4, GrouperUtil.length(outputLines));
8277
8278 assertTrue(GrouperClientWs.mostRecentRequest,
8279 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8280 assertTrue(GrouperClientWs.mostRecentRequest,
8281 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8282 assertTrue(GrouperClientWs.mostRecentRequest,
8283 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8284 assertTrue(GrouperClientWs.mostRecentRequest,
8285 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8286 assertTrue(GrouperClientWs.mostRecentRequest,
8287 !GrouperClientWs.mostRecentRequest.contains("params"));
8288 assertTrue(GrouperClientWs.mostRecentRequest,
8289 GrouperClientWs.mostRecentRequest.contains("fieldName")
8290 && GrouperClientWs.mostRecentRequest.contains("members"));
8291 assertTrue(GrouperClientWs.mostRecentRequest,
8292 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8293
8294
8295
8296
8297 baos = new ByteArrayOutputStream();
8298 System.setOut(new PrintStream(baos));
8299
8300 GrouperClient
8301 .main(GrouperClientUtils
8302 .splitTrim(
8303 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsSubjectId=GrouperSystem",
8304 " "));
8305 System.out.flush();
8306 output = new String(baos.toByteArray());
8307
8308 System.setOut(systemOut);
8309
8310 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8311
8312 assertEquals(4, GrouperUtil.length(outputLines));
8313
8314 assertTrue(GrouperClientWs.mostRecentRequest,
8315 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8316 assertTrue(GrouperClientWs.mostRecentRequest,
8317 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8318 assertTrue(GrouperClientWs.mostRecentRequest,
8319 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8320 assertTrue(GrouperClientWs.mostRecentRequest,
8321 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8322 assertTrue(GrouperClientWs.mostRecentRequest,
8323 !GrouperClientWs.mostRecentRequest.contains("params"));
8324 assertTrue(GrouperClientWs.mostRecentRequest,
8325 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8326 assertTrue(GrouperClientWs.mostRecentRequest,
8327 GrouperClientWs.mostRecentRequest.contains("actAsSubject")
8328 && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
8329
8330
8331
8332
8333 baos = new ByteArrayOutputStream();
8334 System.setOut(new PrintStream(baos));
8335
8336 GrouperClient
8337 .main(GrouperClientUtils
8338 .splitTrim(
8339 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsPennId=GrouperSystem",
8340 " "));
8341 System.out.flush();
8342 output = new String(baos.toByteArray());
8343
8344 System.setOut(systemOut);
8345
8346 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8347
8348 assertEquals(4, GrouperUtil.length(outputLines));
8349
8350 assertTrue(GrouperClientWs.mostRecentRequest,
8351 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8352 assertTrue(GrouperClientWs.mostRecentRequest,
8353 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8354 assertTrue(GrouperClientWs.mostRecentRequest,
8355 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8356 assertTrue(GrouperClientWs.mostRecentRequest,
8357 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8358 assertTrue(GrouperClientWs.mostRecentRequest,
8359 !GrouperClientWs.mostRecentRequest.contains("params"));
8360 assertTrue(GrouperClientWs.mostRecentRequest,
8361 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8362 assertTrue(GrouperClientWs.mostRecentRequest,
8363 GrouperClientWs.mostRecentRequest.contains("actAsSubject")
8364 && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
8365 assertTrue(GrouperClientWs.mostRecentRequest,
8366 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8367 assertTrue(GrouperClientWs.mostRecentRequest,
8368 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8369 assertTrue(GrouperClientWs.mostRecentRequest,
8370 !GrouperClientWs.mostRecentRequest.contains("scope"));
8371
8372 assertTrue(GrouperClientWs.mostRecentRequest,
8373 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8374 assertTrue(GrouperClientWs.mostRecentRequest,
8375 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8376 assertTrue(GrouperClientWs.mostRecentRequest,
8377 !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8378 assertTrue(GrouperClientWs.mostRecentRequest,
8379 !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8380 assertTrue(GrouperClientWs.mostRecentRequest,
8381 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8382
8383
8384
8385
8386
8387 baos = new ByteArrayOutputStream();
8388 System.setOut(new PrintStream(baos));
8389
8390 GrouperClient
8391 .main(GrouperClientUtils
8392 .splitTrim(
8393 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --enabled=F",
8394 " "));
8395 System.out.flush();
8396 output = new String(baos.toByteArray());
8397
8398 System.setOut(systemOut);
8399
8400 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8401
8402 assertEquals(0, GrouperUtil.length(outputLines));
8403
8404 assertTrue(GrouperClientWs.mostRecentRequest,
8405 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8406 assertTrue(GrouperClientWs.mostRecentRequest,
8407 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8408 assertTrue(GrouperClientWs.mostRecentRequest,
8409 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8410 assertTrue(GrouperClientWs.mostRecentRequest,
8411 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8412 assertTrue(GrouperClientWs.mostRecentRequest,
8413 !GrouperClientWs.mostRecentRequest.contains("params"));
8414 assertTrue(GrouperClientWs.mostRecentRequest,
8415 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8416 assertTrue(GrouperClientWs.mostRecentRequest,
8417 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8418 assertTrue(GrouperClientWs.mostRecentRequest,
8419 GrouperClientWs.mostRecentRequest.contains("enabled"));
8420 assertTrue(GrouperClientWs.mostRecentRequest,
8421 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8422 assertTrue(GrouperClientWs.mostRecentRequest,
8423 !GrouperClientWs.mostRecentRequest.contains("scope"));
8424
8425 assertTrue(GrouperClientWs.mostRecentRequest,
8426 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8427 assertTrue(GrouperClientWs.mostRecentRequest,
8428 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8429 assertTrue(GrouperClientWs.mostRecentRequest,
8430 !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8431 assertTrue(GrouperClientWs.mostRecentRequest,
8432 !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8433 assertTrue(GrouperClientWs.mostRecentRequest,
8434 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8435
8436
8437
8438
8439 baos = new ByteArrayOutputStream();
8440 System.setOut(new PrintStream(baos));
8441
8442 GrouperClient
8443 .main(GrouperClientUtils
8444 .splitTrim(
8445 "--operation=getMembershipsWs --subjectIds=test.subject.0,test.subject.1",
8446 " "));
8447 System.out.flush();
8448 output = new String(baos.toByteArray());
8449
8450 System.setOut(systemOut);
8451
8452 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8453
8454 assertEquals(2, GrouperUtil.length(outputLines));
8455
8456 assertTrue(GrouperClientWs.mostRecentRequest,
8457 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8458 assertTrue(GrouperClientWs.mostRecentRequest,
8459 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8460 assertTrue(GrouperClientWs.mostRecentRequest,
8461 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8462 assertTrue(GrouperClientWs.mostRecentRequest,
8463 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8464 assertTrue(GrouperClientWs.mostRecentRequest,
8465 !GrouperClientWs.mostRecentRequest.contains("params"));
8466 assertTrue(GrouperClientWs.mostRecentRequest,
8467 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8468 assertTrue(GrouperClientWs.mostRecentRequest,
8469 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8470 assertTrue(GrouperClientWs.mostRecentRequest,
8471 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8472 assertTrue(GrouperClientWs.mostRecentRequest,
8473 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8474 assertTrue(GrouperClientWs.mostRecentRequest,
8475 !GrouperClientWs.mostRecentRequest.contains("scope"));
8476
8477 assertTrue(GrouperClientWs.mostRecentRequest,
8478 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8479 assertTrue(GrouperClientWs.mostRecentRequest,
8480 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8481 assertTrue(GrouperClientWs.mostRecentRequest,
8482 !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8483 assertTrue(GrouperClientWs.mostRecentRequest,
8484 !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8485 assertTrue(GrouperClientWs.mostRecentRequest,
8486 !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8487 assertTrue(GrouperClientWs.mostRecentRequest,
8488 GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8489
8490
8491
8492
8493
8494
8495
8496
8497
8498
8499
8500
8501
8502
8503
8504
8505
8506
8507
8508
8509
8510 pattern = Pattern
8511 .compile("^Index: (\\d+)\\: (group|folder)\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
8512
8513 baos = new ByteArrayOutputStream();
8514 System.setOut(new PrintStream(baos));
8515
8516 GrouperClient
8517 .main(GrouperClientUtils
8518 .splitTrim(
8519 "--operation=getMembershipsWs --subjectIds=test.subject.7,test.subject.8 --fieldType=access",
8520 " "));
8521 System.out.flush();
8522 output = new String(baos.toByteArray());
8523
8524 System.setOut(systemOut);
8525
8526 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8527
8528 assertEquals(4, GrouperUtil.length(outputLines));
8529
8530 outputLine = outputLines[0];
8531
8532 matcher = pattern.matcher(outputLine);
8533
8534 assertTrue(outputLine, matcher.matches());
8535 assertEquals(outputLine, "0", matcher.group(1));
8536 assertEquals(outputLine, "group", matcher.group(2));
8537 assertEquals(outputLine, "aStem:aGroup", matcher.group(3));
8538 assertEquals(outputLine, "test.subject.7", matcher.group(4));
8539 assertEquals(outputLine, "updaters", matcher.group(5));
8540 assertEquals(outputLine, "immediate", matcher.group(6));
8541 assertEquals(outputLine, "T", matcher.group(7));
8542
8543 outputLine = outputLines[1];
8544
8545 matcher = pattern.matcher(outputLine);
8546
8547 assertTrue(outputLine, matcher.matches());
8548
8549 assertEquals(outputLine, "1", matcher.group(1));
8550 assertEquals(outputLine, "group", matcher.group(2));
8551 assertEquals(outputLine, "aStem:aGroup", matcher.group(3));
8552 assertEquals(outputLine, "test.subject.8", matcher.group(4));
8553 assertEquals(outputLine, "admins", matcher.group(5));
8554 assertEquals(outputLine, "immediate", matcher.group(6));
8555 assertEquals(outputLine, "T", matcher.group(7));
8556
8557 outputLine = outputLines[2];
8558
8559 matcher = pattern.matcher(outputLine);
8560
8561 assertTrue(outputLine, matcher.matches());
8562
8563 assertEquals(outputLine, "2", matcher.group(1));
8564 assertEquals(outputLine, "group", matcher.group(2));
8565 assertEquals(outputLine, "aStem:aGroup2", matcher.group(3));
8566 assertEquals(outputLine, "test.subject.7", matcher.group(4));
8567 assertEquals(outputLine, "updaters", matcher.group(5));
8568 assertEquals(outputLine, "immediate", matcher.group(6));
8569 assertEquals(outputLine, "T", matcher.group(7));
8570
8571 outputLine = outputLines[3];
8572
8573 matcher = pattern.matcher(outputLine);
8574
8575 assertTrue(outputLine, matcher.matches());
8576
8577 assertEquals(outputLine, "3", matcher.group(1));
8578 assertEquals(outputLine, "group", matcher.group(2));
8579 assertEquals(outputLine, "aStem:aGroup2", matcher.group(3));
8580 assertEquals(outputLine, "test.subject.8", matcher.group(4));
8581 assertEquals(outputLine, "admins", matcher.group(5));
8582 assertEquals(outputLine, "immediate", matcher.group(6));
8583 assertEquals(outputLine, "T", matcher.group(7));
8584
8585 assertTrue(GrouperClientWs.mostRecentRequest,
8586 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8587 assertTrue(GrouperClientWs.mostRecentRequest,
8588 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8589 assertTrue(GrouperClientWs.mostRecentRequest,
8590 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8591 assertTrue(GrouperClientWs.mostRecentRequest,
8592 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8593 assertTrue(GrouperClientWs.mostRecentRequest,
8594 !GrouperClientWs.mostRecentRequest.contains("params"));
8595 assertTrue(GrouperClientWs.mostRecentRequest,
8596 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8597 assertTrue(GrouperClientWs.mostRecentRequest,
8598 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8599 assertTrue(GrouperClientWs.mostRecentRequest,
8600 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8601 assertTrue(GrouperClientWs.mostRecentRequest,
8602 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8603 assertTrue(GrouperClientWs.mostRecentRequest,
8604 !GrouperClientWs.mostRecentRequest.contains("scope"));
8605
8606 assertTrue(GrouperClientWs.mostRecentRequest,
8607 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8608 assertTrue(GrouperClientWs.mostRecentRequest,
8609 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8610 assertTrue(GrouperClientWs.mostRecentRequest,
8611 !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8612 assertTrue(GrouperClientWs.mostRecentRequest,
8613 !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8614 assertTrue(GrouperClientWs.mostRecentRequest,
8615 !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8616 assertTrue(GrouperClientWs.mostRecentRequest,
8617 GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8618 assertTrue(GrouperClientWs.mostRecentRequest,
8619 GrouperClientWs.mostRecentRequest.contains("fieldType"));
8620 assertTrue(GrouperClientWs.mostRecentRequest,
8621 GrouperClientWs.mostRecentRequest.contains("access"));
8622
8623
8624
8625
8626 baos = new ByteArrayOutputStream();
8627 System.setOut(new PrintStream(baos));
8628
8629 GrouperClient
8630 .main(GrouperClientUtils
8631 .splitTrim(
8632 "--operation=getMembershipsWs --subjectIds=test.subject.7,test.subject.8 --fieldType=naming --stemIdIndex=" + aStem.getParentStem().getIdIndex() + " --stemScope=ONE_LEVEL",
8633 " "));
8634 System.out.flush();
8635 output = new String(baos.toByteArray());
8636
8637 System.setOut(systemOut);
8638
8639 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8640
8641 assertEquals(output, 4, GrouperUtil.length(outputLines));
8642
8643 outputLine = outputLines[0];
8644
8645 matcher = pattern.matcher(outputLine);
8646
8647 assertTrue(outputLine, matcher.matches());
8648 assertEquals(outputLine, "0", matcher.group(1));
8649 assertEquals(outputLine, "folder", matcher.group(2));
8650 assertEquals(outputLine, "aStem1", matcher.group(3));
8651 assertEquals(outputLine, "test.subject.7", matcher.group(4));
8652 assertEquals(outputLine, "creators", matcher.group(5));
8653 assertEquals(outputLine, "immediate", matcher.group(6));
8654 assertEquals(outputLine, "T", matcher.group(7));
8655
8656 outputLine = outputLines[1];
8657
8658 matcher = pattern.matcher(outputLine);
8659
8660 assertTrue(outputLine, matcher.matches());
8661
8662 assertEquals(outputLine, "1", matcher.group(1));
8663 assertEquals(outputLine, "folder", matcher.group(2));
8664 assertEquals(outputLine, "aStem1", matcher.group(3));
8665 assertEquals(outputLine, "test.subject.8", matcher.group(4));
8666 assertEquals(outputLine, "stemAdmins", matcher.group(5));
8667 assertEquals(outputLine, "immediate", matcher.group(6));
8668 assertEquals(outputLine, "T", matcher.group(7));
8669
8670 outputLine = outputLines[2];
8671
8672 matcher = pattern.matcher(outputLine);
8673
8674 assertTrue(outputLine, matcher.matches());
8675
8676 assertEquals(outputLine, "2", matcher.group(1));
8677 assertEquals(outputLine, "folder", matcher.group(2));
8678 assertEquals(outputLine, "aStem2", matcher.group(3));
8679 assertEquals(outputLine, "test.subject.7", matcher.group(4));
8680 assertEquals(outputLine, "creators", matcher.group(5));
8681 assertEquals(outputLine, "immediate", matcher.group(6));
8682 assertEquals(outputLine, "T", matcher.group(7));
8683
8684 outputLine = outputLines[3];
8685
8686 matcher = pattern.matcher(outputLine);
8687
8688 assertTrue(outputLine, matcher.matches());
8689
8690 assertEquals(outputLine, "3", matcher.group(1));
8691 assertEquals(outputLine, "folder", matcher.group(2));
8692 assertEquals(outputLine, "aStem2", matcher.group(3));
8693 assertEquals(outputLine, "test.subject.8", matcher.group(4));
8694 assertEquals(outputLine, "stemAdmins", matcher.group(5));
8695 assertEquals(outputLine, "immediate", matcher.group(6));
8696 assertEquals(outputLine, "T", matcher.group(7));
8697
8698 assertTrue(GrouperClientWs.mostRecentRequest,
8699 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8700 assertTrue(GrouperClientWs.mostRecentRequest,
8701 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8702 assertTrue(GrouperClientWs.mostRecentRequest,
8703 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8704 assertTrue(GrouperClientWs.mostRecentRequest,
8705 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8706 assertTrue(GrouperClientWs.mostRecentRequest,
8707 !GrouperClientWs.mostRecentRequest.contains("params"));
8708 assertTrue(GrouperClientWs.mostRecentRequest,
8709 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8710 assertTrue(GrouperClientWs.mostRecentRequest,
8711 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8712 assertTrue(GrouperClientWs.mostRecentRequest,
8713 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8714 assertTrue(GrouperClientWs.mostRecentRequest,
8715 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8716 assertTrue(GrouperClientWs.mostRecentRequest,
8717 !GrouperClientWs.mostRecentRequest.contains("scope"));
8718
8719 assertTrue(GrouperClientWs.mostRecentRequest,
8720 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8721 assertTrue(GrouperClientWs.mostRecentRequest,
8722 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8723 assertTrue(GrouperClientWs.mostRecentRequest,
8724 GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8725 assertTrue(GrouperClientWs.mostRecentRequest,
8726 GrouperClientWs.mostRecentRequest.contains("stemScope"));
8727 assertTrue(GrouperClientWs.mostRecentRequest,
8728 !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8729 assertTrue(GrouperClientWs.mostRecentRequest,
8730 GrouperClientWs.mostRecentRequest.contains("idIndex"));
8731 assertTrue(GrouperClientWs.mostRecentRequest,
8732 GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8733 assertTrue(GrouperClientWs.mostRecentRequest,
8734 GrouperClientWs.mostRecentRequest.contains("ONE_LEVEL"));
8735 assertTrue(GrouperClientWs.mostRecentRequest,
8736 GrouperClientWs.mostRecentRequest.contains("naming"));
8737
8738
8739
8740
8741
8742
8743
8744
8745
8746 baos = new ByteArrayOutputStream();
8747 System.setOut(new PrintStream(baos));
8748
8749 GrouperClient
8750 .main(GrouperClientUtils
8751 .splitTrim(
8752 "--operation=getMembershipsWs --subjectIds=test.subject.7,test.subject.8 --fieldType=naming",
8753 " "));
8754 System.out.flush();
8755 output = new String(baos.toByteArray());
8756
8757 System.setOut(systemOut);
8758
8759 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8760
8761 assertEquals(4, GrouperUtil.length(outputLines));
8762
8763 outputLine = outputLines[0];
8764
8765 matcher = pattern.matcher(outputLine);
8766
8767 assertTrue(outputLine, matcher.matches());
8768 assertEquals(outputLine, "0", matcher.group(1));
8769 assertEquals(outputLine, "folder", matcher.group(2));
8770 assertEquals(outputLine, "aStem1", matcher.group(3));
8771 assertEquals(outputLine, "test.subject.7", matcher.group(4));
8772 assertEquals(outputLine, "creators", matcher.group(5));
8773 assertEquals(outputLine, "immediate", matcher.group(6));
8774 assertEquals(outputLine, "T", matcher.group(7));
8775
8776 outputLine = outputLines[1];
8777
8778 matcher = pattern.matcher(outputLine);
8779
8780 assertTrue(outputLine, matcher.matches());
8781
8782 assertEquals(outputLine, "1", matcher.group(1));
8783 assertEquals(outputLine, "folder", matcher.group(2));
8784 assertEquals(outputLine, "aStem1", matcher.group(3));
8785 assertEquals(outputLine, "test.subject.8", matcher.group(4));
8786 assertEquals(outputLine, "stemAdmins", matcher.group(5));
8787 assertEquals(outputLine, "immediate", matcher.group(6));
8788 assertEquals(outputLine, "T", matcher.group(7));
8789
8790 outputLine = outputLines[2];
8791
8792 matcher = pattern.matcher(outputLine);
8793
8794 assertTrue(outputLine, matcher.matches());
8795
8796 assertEquals(outputLine, "2", matcher.group(1));
8797 assertEquals(outputLine, "folder", matcher.group(2));
8798 assertEquals(outputLine, "aStem2", matcher.group(3));
8799 assertEquals(outputLine, "test.subject.7", matcher.group(4));
8800 assertEquals(outputLine, "creators", matcher.group(5));
8801 assertEquals(outputLine, "immediate", matcher.group(6));
8802 assertEquals(outputLine, "T", matcher.group(7));
8803
8804 outputLine = outputLines[3];
8805
8806 matcher = pattern.matcher(outputLine);
8807
8808 assertTrue(outputLine, matcher.matches());
8809
8810 assertEquals(outputLine, "3", matcher.group(1));
8811 assertEquals(outputLine, "folder", matcher.group(2));
8812 assertEquals(outputLine, "aStem2", matcher.group(3));
8813 assertEquals(outputLine, "test.subject.8", matcher.group(4));
8814 assertEquals(outputLine, "stemAdmins", matcher.group(5));
8815 assertEquals(outputLine, "immediate", matcher.group(6));
8816 assertEquals(outputLine, "T", matcher.group(7));
8817
8818 assertTrue(GrouperClientWs.mostRecentRequest,
8819 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8820 assertTrue(GrouperClientWs.mostRecentRequest,
8821 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8822 assertTrue(GrouperClientWs.mostRecentRequest,
8823 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8824 assertTrue(GrouperClientWs.mostRecentRequest,
8825 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8826 assertTrue(GrouperClientWs.mostRecentRequest,
8827 !GrouperClientWs.mostRecentRequest.contains("params"));
8828 assertTrue(GrouperClientWs.mostRecentRequest,
8829 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8830 assertTrue(GrouperClientWs.mostRecentRequest,
8831 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8832 assertTrue(GrouperClientWs.mostRecentRequest,
8833 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8834 assertTrue(GrouperClientWs.mostRecentRequest,
8835 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8836 assertTrue(GrouperClientWs.mostRecentRequest,
8837 !GrouperClientWs.mostRecentRequest.contains("scope"));
8838
8839 assertTrue(GrouperClientWs.mostRecentRequest,
8840 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8841 assertTrue(GrouperClientWs.mostRecentRequest,
8842 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8843 assertTrue(GrouperClientWs.mostRecentRequest,
8844 !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8845 assertTrue(GrouperClientWs.mostRecentRequest,
8846 !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8847 assertTrue(GrouperClientWs.mostRecentRequest,
8848 !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8849 assertTrue(GrouperClientWs.mostRecentRequest,
8850 GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8851 assertTrue(GrouperClientWs.mostRecentRequest,
8852 GrouperClientWs.mostRecentRequest.contains("fieldType"));
8853 assertTrue(GrouperClientWs.mostRecentRequest,
8854 GrouperClientWs.mostRecentRequest.contains("naming"));
8855
8856
8857
8858
8859
8860
8861
8862
8863
8864 baos = new ByteArrayOutputStream();
8865 System.setOut(new PrintStream(baos));
8866
8867 GrouperClient
8868 .main(GrouperClientUtils
8869 .splitTrim(
8870 "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --stemName=aStem --stemScope=ALL_IN_SUBTREE",
8871 " "));
8872 System.out.flush();
8873 output = new String(baos.toByteArray());
8874
8875 System.setOut(systemOut);
8876
8877 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8878
8879 assertEquals(4, GrouperUtil.length(outputLines));
8880
8881 assertTrue(GrouperClientWs.mostRecentRequest,
8882 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8883 assertTrue(GrouperClientWs.mostRecentRequest,
8884 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8885 assertTrue(GrouperClientWs.mostRecentRequest,
8886 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8887 assertTrue(GrouperClientWs.mostRecentRequest,
8888 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8889 assertTrue(GrouperClientWs.mostRecentRequest,
8890 !GrouperClientWs.mostRecentRequest.contains("params"));
8891 assertTrue(GrouperClientWs.mostRecentRequest,
8892 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8893 assertTrue(GrouperClientWs.mostRecentRequest,
8894 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8895 assertTrue(GrouperClientWs.mostRecentRequest,
8896 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8897 assertTrue(GrouperClientWs.mostRecentRequest,
8898 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8899 assertTrue(GrouperClientWs.mostRecentRequest,
8900 !GrouperClientWs.mostRecentRequest.contains("scope"));
8901
8902 assertTrue(GrouperClientWs.mostRecentRequest,
8903 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8904 assertTrue(GrouperClientWs.mostRecentRequest,
8905 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8906 assertTrue(GrouperClientWs.mostRecentRequest,
8907 GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8908 assertTrue(GrouperClientWs.mostRecentRequest,
8909 GrouperClientWs.mostRecentRequest.contains("stemScope"));
8910 assertTrue(GrouperClientWs.mostRecentRequest,
8911 GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8912 assertTrue(GrouperClientWs.mostRecentRequest,
8913 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8914 assertTrue(GrouperClientWs.mostRecentRequest,
8915 !GrouperClientWs.mostRecentRequest.contains("fieldType"));
8916 assertTrue(GrouperClientWs.mostRecentRequest,
8917 !GrouperClientWs.mostRecentRequest.contains("attributeDef"));
8918
8919
8920
8921
8922 baos = new ByteArrayOutputStream();
8923 System.setOut(new PrintStream(baos));
8924
8925 GrouperClient
8926 .main(GrouperClientUtils
8927 .splitTrim(
8928 "--operation=getMembershipsWs --subjectIds=test.subject.0,test.subject.1",
8929 " "));
8930 System.out.flush();
8931 output = new String(baos.toByteArray());
8932
8933 System.setOut(systemOut);
8934
8935 outputLines = GrouperClientUtils.splitTrim(output, "\n");
8936
8937 assertEquals(2, GrouperUtil.length(outputLines));
8938
8939 assertTrue(GrouperClientWs.mostRecentRequest,
8940 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8941 assertTrue(GrouperClientWs.mostRecentRequest,
8942 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8943 assertTrue(GrouperClientWs.mostRecentRequest,
8944 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8945 assertTrue(GrouperClientWs.mostRecentRequest,
8946 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8947 assertTrue(GrouperClientWs.mostRecentRequest,
8948 !GrouperClientWs.mostRecentRequest.contains("params"));
8949 assertTrue(GrouperClientWs.mostRecentRequest,
8950 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8951 assertTrue(GrouperClientWs.mostRecentRequest,
8952 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8953 assertTrue(GrouperClientWs.mostRecentRequest,
8954 !GrouperClientWs.mostRecentRequest.contains("enabled"));
8955 assertTrue(GrouperClientWs.mostRecentRequest,
8956 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8957 assertTrue(GrouperClientWs.mostRecentRequest,
8958 !GrouperClientWs.mostRecentRequest.contains("scope"));
8959
8960 assertTrue(GrouperClientWs.mostRecentRequest,
8961 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8962 assertTrue(GrouperClientWs.mostRecentRequest,
8963 !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8964 assertTrue(GrouperClientWs.mostRecentRequest,
8965 !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8966 assertTrue(GrouperClientWs.mostRecentRequest,
8967 !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8968 assertTrue(GrouperClientWs.mostRecentRequest,
8969 !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8970 assertTrue(GrouperClientWs.mostRecentRequest,
8971 GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8972
8973
8974 } finally {
8975 System.setOut(systemOut);
8976 }
8977
8978 }
8979
8980
8981
8982
8983 public void testGetSubjects() throws Exception {
8984
8985
8986 GrouperSession grouperSession = GrouperSession.startRootSession();
8987 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
8988 "aStem:aGroup", "aGroup", null, null, true);
8989 Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
8990 "aStem:aGroup2", "aGroup2", null, null, true);
8991
8992
8993 String wsUserLabel = GrouperClientUtils.propertiesValue(
8994 "grouperClient.webService.user.label", true);
8995 String wsUserString = GrouperClientUtils.propertiesValue(
8996 "grouperClient.webService." + wsUserLabel, true);
8997 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
8998
8999 group.grantPriv(wsUser, AccessPrivilege.READ, false);
9000 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
9001 group2.grantPriv(wsUser, AccessPrivilege.READ, false);
9002 group2.grantPriv(wsUser, AccessPrivilege.VIEW, false);
9003
9004
9005 group.addMember(SubjectTestHelper.SUBJ0, false);
9006 group.addMember(SubjectTestHelper.SUBJ1, false);
9007 group2.addMember(SubjectTestHelper.SUBJ2, false);
9008 group2.addMember(SubjectTestHelper.SUBJ3, false);
9009
9010 PrintStream systemOut = System.out;
9011
9012 ByteArrayOutputStream baos = new ByteArrayOutputStream();
9013 System.setOut(new PrintStream(baos));
9014
9015 try {
9016
9017 GrouperClient.main(GrouperClientUtils.splitTrim(
9018 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID,
9019 " "));
9020 System.out.flush();
9021 String output = new String(baos.toByteArray());
9022
9023 System.setOut(systemOut);
9024
9025 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
9026
9027 assertEquals(2, outputLines.length);
9028
9029
9030
9031 Pattern pattern = Pattern
9032 .compile("^Index: (\\d+)\\: success: (T|F), code: (.+), subject\\: (.+)$");
9033
9034 String outputLine = outputLines[0];
9035
9036 Matcher matcher = pattern.matcher(outputLines[0]);
9037
9038 assertTrue(outputLine, matcher.matches());
9039 assertEquals(outputLine, "0", matcher.group(1));
9040 assertEquals(outputLine, "T", matcher.group(2));
9041 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9042 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9043
9044 outputLine = outputLines[1];
9045
9046 matcher = pattern.matcher(outputLine);
9047
9048 assertTrue(outputLine, matcher.matches());
9049
9050 assertEquals(outputLine, "1", matcher.group(1));
9051 assertEquals(outputLine, "T", matcher.group(2));
9052 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9053 assertEquals(outputLine, "test.subject.1", matcher.group(4));
9054
9055 assertTrue(GrouperClientWs.mostRecentRequest,
9056 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9057 assertTrue(GrouperClientWs.mostRecentRequest,
9058 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9059 assertTrue(GrouperClientWs.mostRecentRequest,
9060 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9061 assertTrue(GrouperClientWs.mostRecentRequest,
9062 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9063 assertTrue(GrouperClientWs.mostRecentRequest,
9064 !GrouperClientWs.mostRecentRequest.contains("params"));
9065 assertTrue(GrouperClientWs.mostRecentRequest,
9066 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9067 assertTrue(GrouperClientWs.mostRecentRequest,
9068 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9069
9070
9071
9072
9073 baos = new ByteArrayOutputStream();
9074 System.setOut(new PrintStream(baos));
9075
9076 GrouperClient.main(GrouperClientUtils.splitTrim(
9077 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=jdbc,g:gsa",
9078 " "));
9079
9080 System.out.flush();
9081 output = new String(baos.toByteArray());
9082
9083 System.setOut(systemOut);
9084
9085 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9086
9087 assertEquals(output, 2, GrouperUtil.length(outputLines));
9088
9089 outputLine = outputLines[0];
9090
9091 matcher = pattern.matcher(outputLines[0]);
9092
9093 assertTrue(outputLine, matcher.matches());
9094
9095 assertEquals(outputLine, "0", matcher.group(1));
9096 assertEquals(outputLine, "F", matcher.group(2));
9097 assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9098 assertEquals(outputLine, "test.subject.1", matcher.group(4));
9099
9100 outputLine = outputLines[1];
9101
9102 matcher = pattern.matcher(outputLine);
9103
9104 assertTrue(outputLine, matcher.matches());
9105
9106 assertEquals(outputLine, "1", matcher.group(1));
9107 assertEquals(output, "T", matcher.group(2));
9108 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9109 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9110
9111 assertTrue(GrouperClientWs.mostRecentRequest,
9112 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9113 assertTrue(GrouperClientWs.mostRecentRequest,
9114 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9115 assertTrue(GrouperClientWs.mostRecentRequest,
9116 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9117 assertTrue(GrouperClientWs.mostRecentRequest,
9118 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9119 assertTrue(GrouperClientWs.mostRecentRequest,
9120 !GrouperClientWs.mostRecentRequest.contains("params"));
9121 assertTrue(GrouperClientWs.mostRecentRequest,
9122 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9123 assertTrue(GrouperClientWs.mostRecentRequest,
9124 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9125
9126
9127
9128
9129 baos = new ByteArrayOutputStream();
9130 System.setOut(new PrintStream(baos));
9131
9132 GrouperClient.main(GrouperClientUtils.splitTrim(
9133 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=jdbc",
9134 " "));
9135
9136 System.out.flush();
9137 output = new String(baos.toByteArray());
9138
9139 System.setOut(systemOut);
9140
9141 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9142
9143 assertEquals(output, 2, GrouperUtil.length(outputLines));
9144
9145 outputLine = outputLines[0];
9146
9147 matcher = pattern.matcher(outputLines[0]);
9148
9149 assertTrue(outputLine, matcher.matches());
9150 assertEquals(outputLine, "0", matcher.group(1));
9151 assertEquals(outputLine, "T", matcher.group(2));
9152 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9153 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9154
9155 outputLine = outputLines[1];
9156
9157 matcher = pattern.matcher(outputLine);
9158
9159 assertTrue(outputLine, matcher.matches());
9160
9161 assertEquals(outputLine, "1", matcher.group(1));
9162 assertEquals(outputLine, "T", matcher.group(2));
9163 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9164 assertEquals(outputLine, "test.subject.1", matcher.group(4));
9165
9166 assertTrue(GrouperClientWs.mostRecentRequest,
9167 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9168 assertTrue(GrouperClientWs.mostRecentRequest,
9169 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9170 assertTrue(GrouperClientWs.mostRecentRequest,
9171 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9172 assertTrue(GrouperClientWs.mostRecentRequest,
9173 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9174 assertTrue(GrouperClientWs.mostRecentRequest,
9175 !GrouperClientWs.mostRecentRequest.contains("params"));
9176 assertTrue(GrouperClientWs.mostRecentRequest,
9177 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9178 assertTrue(GrouperClientWs.mostRecentRequest,
9179 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9180
9181
9182
9183
9184 baos = new ByteArrayOutputStream();
9185 System.setOut(new PrintStream(baos));
9186
9187 GrouperClient.main(GrouperClientUtils.splitTrim(
9188 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=g:gsa",
9189 " "));
9190
9191 System.out.flush();
9192 output = new String(baos.toByteArray());
9193
9194 System.setOut(systemOut);
9195
9196 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9197
9198 assertEquals(output, 2, GrouperUtil.length(outputLines));
9199
9200 outputLine = outputLines[0];
9201
9202 matcher = pattern.matcher(outputLines[0]);
9203
9204 assertTrue(outputLine, matcher.matches());
9205 assertEquals(outputLine, "0", matcher.group(1));
9206 assertEquals(outputLine, "F", matcher.group(2));
9207 assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9208 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9209
9210 outputLine = outputLines[1];
9211
9212 matcher = pattern.matcher(outputLine);
9213
9214 assertTrue(outputLine, matcher.matches());
9215
9216 assertEquals(outputLine, "1", matcher.group(1));
9217 assertEquals(outputLine, "F", matcher.group(2));
9218 assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9219 assertEquals(outputLine, "test.subject.1", matcher.group(4));
9220
9221 assertTrue(GrouperClientWs.mostRecentRequest,
9222 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9223 assertTrue(GrouperClientWs.mostRecentRequest,
9224 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9225 assertTrue(GrouperClientWs.mostRecentRequest,
9226 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9227 assertTrue(GrouperClientWs.mostRecentRequest,
9228 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9229 assertTrue(GrouperClientWs.mostRecentRequest,
9230 !GrouperClientWs.mostRecentRequest.contains("params"));
9231 assertTrue(GrouperClientWs.mostRecentRequest,
9232 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9233 assertTrue(GrouperClientWs.mostRecentRequest,
9234 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9235
9236
9237
9238
9239
9240 baos = new ByteArrayOutputStream();
9241 System.setOut(new PrintStream(baos));
9242
9243 GrouperClient.main(GrouperClientUtils.splitTrim(
9244 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=g:gsa,g:gsa",
9245 " "));
9246
9247 System.out.flush();
9248 output = new String(baos.toByteArray());
9249
9250 System.setOut(systemOut);
9251
9252 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9253
9254 assertEquals(output, 2, GrouperUtil.length(outputLines));
9255
9256 outputLine = outputLines[0];
9257
9258 matcher = pattern.matcher(outputLines[0]);
9259
9260 assertTrue(outputLine, matcher.matches());
9261 assertEquals(outputLine, "0", matcher.group(1));
9262 assertEquals(outputLine, "F", matcher.group(2));
9263 assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9264 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9265
9266 outputLine = outputLines[1];
9267
9268 matcher = pattern.matcher(outputLine);
9269
9270 assertTrue(outputLine, matcher.matches());
9271
9272 assertEquals(outputLine, "1", matcher.group(1));
9273 assertEquals(outputLine, "F", matcher.group(2));
9274 assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9275 assertEquals(outputLine, "test.subject.1", matcher.group(4));
9276
9277 assertTrue(GrouperClientWs.mostRecentRequest,
9278 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9279 assertTrue(GrouperClientWs.mostRecentRequest,
9280 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9281 assertTrue(GrouperClientWs.mostRecentRequest,
9282 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9283 assertTrue(GrouperClientWs.mostRecentRequest,
9284 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9285 assertTrue(GrouperClientWs.mostRecentRequest,
9286 !GrouperClientWs.mostRecentRequest.contains("params"));
9287 assertTrue(GrouperClientWs.mostRecentRequest,
9288 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9289 assertTrue(GrouperClientWs.mostRecentRequest,
9290 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9291
9292
9293
9294
9295
9296 baos = new ByteArrayOutputStream();
9297 System.setOut(new PrintStream(baos));
9298
9299 GrouperClient.main(GrouperClientUtils.splitTrim(
9300 "--operation=getSubjectsWs --subjectIdentifiers=id.test.subject.0,id.test.subject.1",
9301 " "));
9302
9303 System.out.flush();
9304 output = new String(baos.toByteArray());
9305
9306 System.setOut(systemOut);
9307
9308 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9309
9310 assertEquals(output, 2, GrouperUtil.length(outputLines));
9311
9312 outputLine = outputLines[0];
9313
9314 matcher = pattern.matcher(outputLines[0]);
9315
9316 assertTrue(outputLine, matcher.matches());
9317 assertEquals(outputLine, "0", matcher.group(1));
9318 assertEquals(outputLine, "T", matcher.group(2));
9319 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9320 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9321
9322 outputLine = outputLines[1];
9323
9324 matcher = pattern.matcher(outputLine);
9325
9326 assertTrue(outputLine, matcher.matches());
9327
9328 assertEquals(outputLine, "1", matcher.group(1));
9329 assertEquals(outputLine, "T", matcher.group(2));
9330 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9331 assertEquals(outputLine, "test.subject.1", matcher.group(4));
9332
9333 assertTrue(GrouperClientWs.mostRecentRequest,
9334 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9335 assertTrue(GrouperClientWs.mostRecentRequest,
9336 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9337 assertTrue(GrouperClientWs.mostRecentRequest,
9338 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9339 assertTrue(GrouperClientWs.mostRecentRequest,
9340 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9341 assertTrue(GrouperClientWs.mostRecentRequest,
9342 !GrouperClientWs.mostRecentRequest.contains("params"));
9343 assertTrue(GrouperClientWs.mostRecentRequest,
9344 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9345 assertTrue(GrouperClientWs.mostRecentRequest,
9346 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9347
9348
9349
9350
9351
9352 baos = new ByteArrayOutputStream();
9353 System.setOut(new PrintStream(baos));
9354
9355 Group aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
9356
9357 GrouperClient.main(GrouperClientUtils.splitTrim(
9358 "--operation=getSubjectsWs --groupUuid=" + aGroup.getUuid() + " --subjectIds=" + SubjectTestHelper.SUBJ5_ID + "," + SubjectTestHelper.SUBJ6_ID,
9359 " "));
9360
9361 System.out.flush();
9362 output = new String(baos.toByteArray());
9363
9364 System.setOut(systemOut);
9365
9366 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9367
9368 assertEquals(output, 0, GrouperUtil.length(outputLines));
9369
9370
9371
9372
9373 baos = new ByteArrayOutputStream();
9374 System.setOut(new PrintStream(baos));
9375
9376 GrouperClient.main(GrouperClientUtils.splitTrim(
9377 "--operation=getSubjectsWs --groupUuid=" + aGroup.getUuid() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ7_ID,
9378 " "));
9379
9380 System.out.flush();
9381 output = new String(baos.toByteArray());
9382
9383 System.setOut(systemOut);
9384
9385 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9386
9387 assertEquals(1, GrouperUtil.length(outputLines));
9388
9389 outputLine = outputLines[0];
9390
9391 matcher = pattern.matcher(outputLines[0]);
9392
9393 assertTrue(outputLine, matcher.matches());
9394 assertEquals(outputLine, "0", matcher.group(1));
9395 assertEquals(outputLine, "T", matcher.group(2));
9396 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9397 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9398
9399 assertTrue(GrouperClientWs.mostRecentRequest,
9400 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9401 assertTrue(GrouperClientWs.mostRecentRequest,
9402 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9403 assertTrue(GrouperClientWs.mostRecentRequest,
9404 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9405 assertTrue(GrouperClientWs.mostRecentRequest,
9406 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9407 assertTrue(GrouperClientWs.mostRecentRequest,
9408 !GrouperClientWs.mostRecentRequest.contains("params"));
9409 assertTrue(GrouperClientWs.mostRecentRequest,
9410 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9411 assertTrue(GrouperClientWs.mostRecentRequest,
9412 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9413 assertTrue(GrouperClientWs.mostRecentRequest,
9414 GrouperClientWs.mostRecentRequest.contains("<wsGroupLookup><uuid>"));
9415
9416
9417
9418
9419 baos = new ByteArrayOutputStream();
9420 System.setOut(new PrintStream(baos));
9421
9422 GrouperClient.main(GrouperClientUtils.splitTrim(
9423 "--operation=getSubjectsWs --groupIdIndex=" + aGroup.getIdIndex() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ7_ID,
9424 " "));
9425
9426 System.out.flush();
9427 output = new String(baos.toByteArray());
9428
9429 System.setOut(systemOut);
9430
9431 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9432
9433 assertEquals(1, GrouperUtil.length(outputLines));
9434
9435 outputLine = outputLines[0];
9436
9437 matcher = pattern.matcher(outputLines[0]);
9438
9439 assertTrue(outputLine, matcher.matches());
9440 assertEquals(outputLine, "0", matcher.group(1));
9441 assertEquals(outputLine, "T", matcher.group(2));
9442 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9443 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9444
9445 assertTrue(GrouperClientWs.mostRecentRequest,
9446 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9447 assertTrue(GrouperClientWs.mostRecentRequest,
9448 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9449 assertTrue(GrouperClientWs.mostRecentRequest,
9450 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9451 assertTrue(GrouperClientWs.mostRecentRequest,
9452 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9453 assertTrue(GrouperClientWs.mostRecentRequest,
9454 !GrouperClientWs.mostRecentRequest.contains("params"));
9455 assertTrue(GrouperClientWs.mostRecentRequest,
9456 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9457 assertTrue(GrouperClientWs.mostRecentRequest,
9458 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9459 assertTrue(GrouperClientWs.mostRecentRequest,
9460 GrouperClientWs.mostRecentRequest.contains("<wsGroupLookup><idIndex>"));
9461
9462
9463
9464
9465 baos = new ByteArrayOutputStream();
9466 System.setOut(new PrintStream(baos));
9467
9468 GrouperClient.main(GrouperClientUtils.splitTrim(
9469 "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ7_ID,
9470 " "));
9471
9472 System.out.flush();
9473 output = new String(baos.toByteArray());
9474
9475 System.setOut(systemOut);
9476
9477 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9478
9479 assertEquals(1, GrouperUtil.length(outputLines));
9480
9481 outputLine = outputLines[0];
9482
9483 matcher = pattern.matcher(outputLines[0]);
9484
9485 assertTrue(outputLine, matcher.matches());
9486 assertEquals(outputLine, "0", matcher.group(1));
9487 assertEquals(outputLine, "T", matcher.group(2));
9488 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9489 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9490
9491 assertTrue(GrouperClientWs.mostRecentRequest,
9492 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9493 assertTrue(GrouperClientWs.mostRecentRequest,
9494 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9495 assertTrue(GrouperClientWs.mostRecentRequest,
9496 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9497 assertTrue(GrouperClientWs.mostRecentRequest,
9498 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9499 assertTrue(GrouperClientWs.mostRecentRequest,
9500 !GrouperClientWs.mostRecentRequest.contains("params"));
9501 assertTrue(GrouperClientWs.mostRecentRequest,
9502 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9503 assertTrue(GrouperClientWs.mostRecentRequest,
9504 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9505 assertTrue(GrouperClientWs.mostRecentRequest,
9506 GrouperClientWs.mostRecentRequest.contains("<wsGroupLookup><groupName>"));
9507
9508
9509
9510
9511 baos = new ByteArrayOutputStream();
9512 System.setOut(new PrintStream(baos));
9513
9514 GrouperClient
9515 .main(GrouperClientUtils
9516 .splitTrim(
9517 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --subjectAttributeNames=a,name --outputTemplate=${wsSubject.getAttributeValue(1)}$newline$",
9518 " "));
9519 System.out.flush();
9520 output = new String(baos.toByteArray());
9521
9522 System.setOut(systemOut);
9523
9524 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9525
9526 assertEquals(1, outputLines.length);
9527 assertEquals(outputLines[0], "my name is test.subject.0");
9528
9529
9530
9531
9532 baos = new ByteArrayOutputStream();
9533 System.setOut(new PrintStream(baos));
9534
9535 GrouperClient
9536 .main(GrouperClientUtils
9537 .splitTrim(
9538 "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --memberFilter=Effective",
9539 " "));
9540 System.out.flush();
9541 output = new String(baos.toByteArray());
9542
9543 System.setOut(systemOut);
9544
9545 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9546
9547 assertEquals(0, GrouperUtil.length(outputLines));
9548
9549 assertTrue(GrouperClientWs.mostRecentRequest,
9550 GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9551 assertTrue(GrouperClientWs.mostRecentRequest,
9552 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9553 assertTrue(GrouperClientWs.mostRecentRequest,
9554 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9555 assertTrue(GrouperClientWs.mostRecentRequest,
9556 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9557 assertTrue(GrouperClientWs.mostRecentRequest,
9558 !GrouperClientWs.mostRecentRequest.contains("params"));
9559 assertTrue(GrouperClientWs.mostRecentRequest,
9560 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9561 assertTrue(GrouperClientWs.mostRecentRequest,
9562 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9563
9564
9565
9566
9567 baos = new ByteArrayOutputStream();
9568 System.setOut(new PrintStream(baos));
9569
9570 GrouperClient
9571 .main(GrouperClientUtils
9572 .splitTrim(
9573 "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --memberFilter=Immediate",
9574 " "));
9575 System.out.flush();
9576 output = new String(baos.toByteArray());
9577
9578 System.setOut(systemOut);
9579
9580 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9581
9582 assertEquals(1, GrouperUtil.length(outputLines));
9583
9584 outputLine = outputLines[0];
9585
9586 matcher = pattern.matcher(outputLines[0]);
9587
9588 assertTrue(outputLine, matcher.matches());
9589 assertEquals(outputLine, "0", matcher.group(1));
9590 assertEquals(outputLine, "T", matcher.group(2));
9591 assertEquals(outputLine, "SUCCESS", matcher.group(3));
9592 assertEquals(outputLine, "test.subject.0", matcher.group(4));
9593
9594 assertTrue(GrouperClientWs.mostRecentRequest,
9595 GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9596 assertTrue(GrouperClientWs.mostRecentRequest,
9597 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9598 assertTrue(GrouperClientWs.mostRecentRequest,
9599 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9600 assertTrue(GrouperClientWs.mostRecentRequest,
9601 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9602 assertTrue(GrouperClientWs.mostRecentRequest,
9603 !GrouperClientWs.mostRecentRequest.contains("params"));
9604 assertTrue(GrouperClientWs.mostRecentRequest,
9605 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9606 assertTrue(GrouperClientWs.mostRecentRequest,
9607 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9608
9609
9610
9611
9612 baos = new ByteArrayOutputStream();
9613 System.setOut(new PrintStream(baos));
9614
9615 GrouperClient
9616 .main(GrouperClientUtils
9617 .splitTrim(
9618 "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --includeGroupDetail=true",
9619 " "));
9620 System.out.flush();
9621 output = new String(baos.toByteArray());
9622
9623 System.setOut(systemOut);
9624
9625 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9626
9627 assertEquals(1, GrouperUtil.length(outputLines));
9628
9629 assertTrue(GrouperClientWs.mostRecentRequest,
9630 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9631 assertTrue(GrouperClientWs.mostRecentRequest,
9632 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9633 assertTrue(GrouperClientWs.mostRecentRequest,
9634 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9635 assertTrue(GrouperClientWs.mostRecentRequest,
9636 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9637 assertTrue(GrouperClientWs.mostRecentRequest,
9638 !GrouperClientWs.mostRecentRequest.contains("params"));
9639 assertTrue(GrouperClientWs.mostRecentRequest,
9640 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9641 assertTrue(GrouperClientWs.mostRecentRequest,
9642 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9643
9644
9645
9646
9647 baos = new ByteArrayOutputStream();
9648 System.setOut(new PrintStream(baos));
9649
9650 GrouperClient
9651 .main(GrouperClientUtils
9652 .splitTrim(
9653 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --includeSubjectDetail=true",
9654 " "));
9655 System.out.flush();
9656 output = new String(baos.toByteArray());
9657
9658 System.setOut(systemOut);
9659
9660 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9661
9662 assertEquals(1, GrouperUtil.length(outputLines));
9663
9664 assertTrue(GrouperClientWs.mostRecentRequest,
9665 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9666 assertTrue(GrouperClientWs.mostRecentRequest,
9667 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9668 assertTrue(GrouperClientWs.mostRecentRequest,
9669 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9670 assertTrue(GrouperClientWs.mostRecentRequest,
9671 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9672 assertTrue(GrouperClientWs.mostRecentRequest,
9673 !GrouperClientWs.mostRecentRequest.contains("params"));
9674 assertTrue(GrouperClientWs.mostRecentRequest,
9675 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9676 assertTrue(GrouperClientWs.mostRecentRequest,
9677 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9678
9679
9680
9681
9682 baos = new ByteArrayOutputStream();
9683 System.setOut(new PrintStream(baos));
9684
9685 GrouperClient
9686 .main(GrouperClientUtils
9687 .splitTrim(
9688 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --subjectAttributeNames=name",
9689 " "));
9690 System.out.flush();
9691 output = new String(baos.toByteArray());
9692
9693 System.setOut(systemOut);
9694
9695 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9696
9697 assertEquals(1, GrouperUtil.length(outputLines));
9698
9699 assertTrue(GrouperClientWs.mostRecentRequest,
9700 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9701 assertTrue(GrouperClientWs.mostRecentRequest,
9702 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9703 assertTrue(GrouperClientWs.mostRecentRequest,
9704 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9705 assertTrue(GrouperClientWs.mostRecentRequest,
9706 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9707 assertTrue(GrouperClientWs.mostRecentRequest,
9708 !GrouperClientWs.mostRecentRequest.contains("params"));
9709 assertTrue(GrouperClientWs.mostRecentRequest,
9710 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9711 assertTrue(GrouperClientWs.mostRecentRequest,
9712 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9713
9714
9715
9716
9717 baos = new ByteArrayOutputStream();
9718 System.setOut(new PrintStream(baos));
9719
9720 GrouperClient
9721 .main(GrouperClientUtils
9722 .splitTrim(
9723 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --paramName0=someParam --paramValue0=someValue",
9724 " "));
9725 System.out.flush();
9726 output = new String(baos.toByteArray());
9727
9728 System.setOut(systemOut);
9729
9730 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9731
9732 assertEquals(1, GrouperUtil.length(outputLines));
9733
9734 assertTrue(GrouperClientWs.mostRecentRequest,
9735 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9736 assertTrue(GrouperClientWs.mostRecentRequest,
9737 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9738 assertTrue(GrouperClientWs.mostRecentRequest,
9739 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9740 assertTrue(GrouperClientWs.mostRecentRequest,
9741 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9742 assertTrue(GrouperClientWs.mostRecentRequest,
9743 GrouperClientWs.mostRecentRequest.contains("someParam")
9744 && GrouperClientWs.mostRecentRequest.toLowerCase().contains(
9745 "params")
9746 && GrouperClientWs.mostRecentRequest.contains("someValue"));
9747 assertTrue(GrouperClientWs.mostRecentRequest,
9748 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9749 assertTrue(GrouperClientWs.mostRecentRequest,
9750 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9751
9752
9753
9754
9755 baos = new ByteArrayOutputStream();
9756 System.setOut(new PrintStream(baos));
9757
9758 GrouperClient
9759 .main(GrouperClientUtils
9760 .splitTrim(
9761 "--operation=getSubjectsWs --groupName=aStem:aGroup --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --fieldName=members",
9762 " "));
9763 System.out.flush();
9764 output = new String(baos.toByteArray());
9765
9766 System.setOut(systemOut);
9767
9768 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9769
9770 assertEquals(1, GrouperUtil.length(outputLines));
9771
9772 assertTrue(GrouperClientWs.mostRecentRequest,
9773 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9774 assertTrue(GrouperClientWs.mostRecentRequest,
9775 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9776 assertTrue(GrouperClientWs.mostRecentRequest,
9777 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9778 assertTrue(GrouperClientWs.mostRecentRequest,
9779 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9780 assertTrue(GrouperClientWs.mostRecentRequest,
9781 !GrouperClientWs.mostRecentRequest.contains("params"));
9782 assertTrue(GrouperClientWs.mostRecentRequest,
9783 GrouperClientWs.mostRecentRequest.contains("fieldName")
9784 && GrouperClientWs.mostRecentRequest.contains("members"));
9785 assertTrue(GrouperClientWs.mostRecentRequest,
9786 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9787
9788
9789
9790
9791 baos = new ByteArrayOutputStream();
9792 System.setOut(new PrintStream(baos));
9793
9794 GrouperClient
9795 .main(GrouperClientUtils
9796 .splitTrim(
9797 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --actAsSubjectId=GrouperSystem",
9798 " "));
9799 System.out.flush();
9800 output = new String(baos.toByteArray());
9801
9802 System.setOut(systemOut);
9803
9804 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9805
9806 assertEquals(1, GrouperUtil.length(outputLines));
9807
9808 assertTrue(GrouperClientWs.mostRecentRequest,
9809 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9810 assertTrue(GrouperClientWs.mostRecentRequest,
9811 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9812 assertTrue(GrouperClientWs.mostRecentRequest,
9813 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9814 assertTrue(GrouperClientWs.mostRecentRequest,
9815 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9816 assertTrue(GrouperClientWs.mostRecentRequest,
9817 !GrouperClientWs.mostRecentRequest.contains("params"));
9818 assertTrue(GrouperClientWs.mostRecentRequest,
9819 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9820 assertTrue(GrouperClientWs.mostRecentRequest,
9821 GrouperClientWs.mostRecentRequest.contains("actAsSubject")
9822 && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
9823
9824
9825
9826
9827 baos = new ByteArrayOutputStream();
9828 System.setOut(new PrintStream(baos));
9829
9830 GrouperClient
9831 .main(GrouperClientUtils
9832 .splitTrim(
9833 "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --actAsPennId=GrouperSystem",
9834 " "));
9835 System.out.flush();
9836 output = new String(baos.toByteArray());
9837
9838 System.setOut(systemOut);
9839
9840 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9841
9842 assertEquals(1, GrouperUtil.length(outputLines));
9843
9844 assertTrue(GrouperClientWs.mostRecentRequest,
9845 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9846 assertTrue(GrouperClientWs.mostRecentRequest,
9847 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9848 assertTrue(GrouperClientWs.mostRecentRequest,
9849 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9850 assertTrue(GrouperClientWs.mostRecentRequest,
9851 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9852 assertTrue(GrouperClientWs.mostRecentRequest,
9853 !GrouperClientWs.mostRecentRequest.contains("params"));
9854 assertTrue(GrouperClientWs.mostRecentRequest,
9855 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9856 assertTrue(GrouperClientWs.mostRecentRequest,
9857 GrouperClientWs.mostRecentRequest.contains("actAsSubject")
9858 && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
9859
9860 assertTrue(GrouperClientWs.mostRecentRequest,
9861 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9862
9863
9864
9865
9866 baos = new ByteArrayOutputStream();
9867 System.setOut(new PrintStream(baos));
9868
9869 GrouperClient
9870 .main(GrouperClientUtils
9871 .splitTrim(
9872 "--operation=getSubjectsWs --searchString=test",
9873 " "));
9874 System.out.flush();
9875 output = new String(baos.toByteArray());
9876
9877 System.setOut(systemOut);
9878
9879 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9880
9881 assertTrue(output, 8 < GrouperUtil.length(outputLines));
9882
9883 assertTrue(GrouperClientWs.mostRecentRequest,
9884 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9885 assertTrue(GrouperClientWs.mostRecentRequest,
9886 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9887 assertTrue(GrouperClientWs.mostRecentRequest,
9888 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9889 assertTrue(GrouperClientWs.mostRecentRequest,
9890 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9891 assertTrue(GrouperClientWs.mostRecentRequest,
9892 !GrouperClientWs.mostRecentRequest.contains("params"));
9893 assertTrue(GrouperClientWs.mostRecentRequest,
9894 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9895 assertTrue(GrouperClientWs.mostRecentRequest,
9896 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9897
9898 assertTrue(GrouperClientWs.mostRecentRequest,
9899 !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9900 assertTrue(GrouperClientWs.mostRecentRequest,
9901 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
9902
9903
9904
9905
9906
9907 baos = new ByteArrayOutputStream();
9908 System.setOut(new PrintStream(baos));
9909
9910 GrouperClient
9911 .main(GrouperClientUtils
9912 .splitTrim(
9913 "--operation=getSubjectsWs --searchString=test --sourceIds=jdbc",
9914 " "));
9915 System.out.flush();
9916 output = new String(baos.toByteArray());
9917
9918 System.setOut(systemOut);
9919
9920 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9921
9922 assertTrue(output, 8 < GrouperUtil.length(outputLines));
9923
9924 assertTrue(GrouperClientWs.mostRecentRequest,
9925 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9926 assertTrue(GrouperClientWs.mostRecentRequest,
9927 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9928 assertTrue(GrouperClientWs.mostRecentRequest,
9929 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9930 assertTrue(GrouperClientWs.mostRecentRequest,
9931 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9932 assertTrue(GrouperClientWs.mostRecentRequest,
9933 !GrouperClientWs.mostRecentRequest.contains("params"));
9934 assertTrue(GrouperClientWs.mostRecentRequest,
9935 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9936 assertTrue(GrouperClientWs.mostRecentRequest,
9937 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9938
9939 assertTrue(GrouperClientWs.mostRecentRequest,
9940 GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9941 assertTrue(GrouperClientWs.mostRecentRequest,
9942 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
9943
9944
9945
9946
9947
9948 baos = new ByteArrayOutputStream();
9949 System.setOut(new PrintStream(baos));
9950
9951 GrouperClient
9952 .main(GrouperClientUtils
9953 .splitTrim(
9954 "--operation=getSubjectsWs --searchString=test --sourceIds=g:gsa",
9955 " "));
9956 System.out.flush();
9957 output = new String(baos.toByteArray());
9958
9959 System.setOut(systemOut);
9960
9961 outputLines = GrouperClientUtils.splitTrim(output, "\n");
9962
9963 assertEquals(output, 0, GrouperUtil.length(outputLines));
9964
9965 assertTrue(GrouperClientWs.mostRecentRequest,
9966 !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9967 assertTrue(GrouperClientWs.mostRecentRequest,
9968 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9969 assertTrue(GrouperClientWs.mostRecentRequest,
9970 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9971 assertTrue(GrouperClientWs.mostRecentRequest,
9972 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9973 assertTrue(GrouperClientWs.mostRecentRequest,
9974 !GrouperClientWs.mostRecentRequest.contains("params"));
9975 assertTrue(GrouperClientWs.mostRecentRequest,
9976 !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9977 assertTrue(GrouperClientWs.mostRecentRequest,
9978 !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9979
9980 assertTrue(GrouperClientWs.mostRecentRequest,
9981 GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9982 assertTrue(GrouperClientWs.mostRecentRequest,
9983 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
9984
9985
9986
9987 } finally {
9988 System.setOut(systemOut);
9989 }
9990
9991 }
9992
9993
9994
9995
9996 public void testAssignGrouperPrivileges() throws Exception {
9997
9998 PrintStream systemOut = System.out;
9999
10000 ByteArrayOutputStream baos = new ByteArrayOutputStream();
10001 System.setOut(new PrintStream(baos));
10002
10003 try {
10004
10005 GrouperClient
10006 .main(GrouperClientUtils
10007 .splitTrim(
10008 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --privilegeNames=optin --allowed=true",
10009 " "));
10010 System.out.flush();
10011 String output = new String(baos.toByteArray());
10012
10013 System.setOut(systemOut);
10014
10015 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
10016
10017 Pattern pattern = Pattern
10018 .compile("^Index: ([0-9]+), success: (T|F), code: (.+), (group|stem): (.*), subject: (.+), (.+): (.+)$");
10019 Matcher matcher = pattern.matcher(outputLines[0]);
10020
10021 assertEquals(output, 1, GrouperClientUtils.length(outputLines));
10022 assertTrue(outputLines[0], matcher.matches());
10023
10024 assertEquals("0", matcher.group(1));
10025 assertEquals("T", matcher.group(2));
10026 assertEquals("SUCCESS_ALLOWED", matcher.group(3));
10027 assertEquals("group", matcher.group(4));
10028 assertEquals("aStem:aGroup", matcher.group(5));
10029 assertEquals("test.subject.0", matcher.group(6));
10030 assertEquals("access", matcher.group(7));
10031 assertEquals("optin", matcher.group(8));
10032
10033
10034
10035 baos = new ByteArrayOutputStream();
10036 System.setOut(new PrintStream(baos));
10037
10038 GrouperClient
10039 .main(GrouperClientUtils
10040 .splitTrim(
10041 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0 --privilegeType=access --privilegeNames=optin --allowed=true",
10042 " "));
10043 System.out.flush();
10044 output = new String(baos.toByteArray());
10045
10046 System.setOut(systemOut);
10047
10048 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10049
10050 matcher = pattern.matcher(outputLines[0]);
10051
10052 assertEquals(GrouperClientUtils.length(outputLines), 1);
10053 assertTrue(outputLines[0], matcher.matches());
10054
10055 assertEquals("0", matcher.group(1));
10056 assertEquals("T", matcher.group(2));
10057 assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(3));
10058 assertEquals("group", matcher.group(4));
10059 assertEquals("aStem:aGroup", matcher.group(5));
10060 assertEquals("test.subject.0", matcher.group(6));
10061 assertEquals("access", matcher.group(7));
10062 assertEquals("optin", matcher.group(8));
10063
10064 assertTrue(GrouperClientWs.mostRecentRequest,
10065 GrouperClientWs.mostRecentRequest.contains("access")
10066 && GrouperClientWs.mostRecentRequest.contains("privilegeType")
10067 && GrouperClientWs.mostRecentRequest
10068 .contains("id.test.subject.0"));
10069
10070
10071
10072 baos = new ByteArrayOutputStream();
10073 System.setOut(new PrintStream(baos));
10074
10075
10076 try {
10077 GrouperClient
10078 .main(GrouperClientUtils
10079 .splitTrim(
10080 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --privilegeNames=optin --allowed=true --ousdfsdfate=${index}",
10081 " "));
10082 } catch (Exception e) {
10083 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
10084 }
10085 System.out.flush();
10086
10087 System.setOut(systemOut);
10088
10089
10090
10091 baos = new ByteArrayOutputStream();
10092 System.setOut(new PrintStream(baos));
10093
10094
10095 GrouperClient
10096 .main(GrouperClientUtils
10097 .splitTrim(
10098 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0 --privilegeNames=optin --allowed=true --outputTemplate=${wsSubject.identifierLookup}",
10099 " "));
10100
10101 System.out.flush();
10102
10103 output = new String(baos.toByteArray());
10104
10105 assertEquals("id.test.subject.0", output);
10106
10107 System.setOut(systemOut);
10108
10109
10110
10111 baos = new ByteArrayOutputStream();
10112 System.setOut(new PrintStream(baos));
10113
10114 GrouperClient
10115 .main(GrouperClientUtils
10116 .splitTrim(
10117 "--operation=assignGrouperPrivilegesWs --stemName=aStem --pennKeys=id.test.subject.0 --privilegeNames=stem --allowed=true",
10118 " "));
10119 System.out.flush();
10120 output = new String(baos.toByteArray());
10121
10122 System.setOut(systemOut);
10123
10124 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10125
10126 matcher = pattern.matcher(outputLines[0]);
10127
10128 assertEquals(GrouperClientUtils.length(outputLines), 1);
10129 assertTrue(outputLines[0], matcher.matches());
10130
10131 assertEquals("0", matcher.group(1));
10132 assertEquals("T", matcher.group(2));
10133 assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(3));
10134 assertEquals("stem", matcher.group(4));
10135 assertEquals("aStem", matcher.group(5));
10136 assertEquals("test.subject.0", matcher.group(6));
10137 assertEquals("naming", matcher.group(7));
10138 assertEquals("stemAdmin", matcher.group(8));
10139
10140
10141
10142 baos = new ByteArrayOutputStream();
10143 System.setOut(new PrintStream(baos));
10144
10145 GrouperClient
10146 .main(GrouperClientUtils
10147 .splitTrim(
10148 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --includeGroupDetail=true --includeSubjectDetail=true --privilegeNames=optin --allowed=false",
10149 " "));
10150 System.out.flush();
10151 output = new String(baos.toByteArray());
10152
10153 System.setOut(systemOut);
10154
10155 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10156
10157 matcher = pattern.matcher(outputLines[0]);
10158
10159 assertEquals(GrouperClientUtils.length(outputLines), 1);
10160 assertTrue(outputLines[0], matcher.matches());
10161
10162 assertEquals("0", matcher.group(1));
10163 assertEquals("T", matcher.group(2));
10164 assertEquals("SUCCESS_NOT_ALLOWED", matcher.group(3));
10165 assertEquals("group", matcher.group(4));
10166 assertEquals("aStem:aGroup", matcher.group(5));
10167 assertEquals("test.subject.0", matcher.group(6));
10168 assertEquals("access", matcher.group(7));
10169 assertEquals("optin", matcher.group(8));
10170
10171 assertTrue(GrouperClientWs.mostRecentRequest
10172 .contains("includeGroupDetail")
10173 && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10174
10175
10176
10177 baos = new ByteArrayOutputStream();
10178 System.setOut(new PrintStream(baos));
10179
10180 GrouperClient
10181 .main(GrouperClientUtils
10182 .splitTrim(
10183 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --subjectAttributeNames=name --privilegeNames=optin --allowed=false --outputTemplate=${index}:$space$${wsSubject.getAttributeValue(0)}$newline$",
10184 " "));
10185 System.out.flush();
10186 output = new String(baos.toByteArray());
10187
10188 System.setOut(systemOut);
10189
10190 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10191
10192 assertTrue(outputLines[0], outputLines[0]
10193 .contains("my name is test.subject.0"));
10194
10195 assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
10196 assertTrue(GrouperClientWs.mostRecentResponse
10197 .contains("my name is test.subject.0"));
10198
10199
10200
10201 baos = new ByteArrayOutputStream();
10202 System.setOut(new PrintStream(baos));
10203
10204 GrouperClient
10205 .main(GrouperClientUtils
10206 .splitTrim(
10207 "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --privilegeNames=optin --allowed=false --subjectIds=test.subject.0 --paramName0=whatever --paramValue0=someValue",
10208 " "));
10209 System.out.flush();
10210 output = new String(baos.toByteArray());
10211
10212 System.setOut(systemOut);
10213
10214 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10215
10216 matcher = pattern.matcher(outputLines[0]);
10217
10218 assertEquals(GrouperClientUtils.length(outputLines), 1);
10219 assertTrue(outputLines[0], matcher.matches());
10220
10221 assertEquals("0", matcher.group(1));
10222 assertEquals("T", matcher.group(2));
10223 assertEquals("SUCCESS_NOT_ALLOWED_DIDNT_EXIST", matcher.group(3));
10224 assertEquals("group", matcher.group(4));
10225 assertEquals("aStem:aGroup", matcher.group(5));
10226 assertEquals("test.subject.0", matcher.group(6));
10227 assertEquals("access", matcher.group(7));
10228 assertEquals("optin", matcher.group(8));
10229
10230 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
10231 && GrouperClientWs.mostRecentRequest.contains("someValue"));
10232
10233
10234
10235 baos = new ByteArrayOutputStream();
10236 System.setOut(new PrintStream(baos));
10237
10238 GrouperSession grouperSession = GrouperSession.startRootSession();
10239
10240 Group replaceGroup = new GroupSave(grouperSession).assignGroupNameToEdit("aStem:replaceExisting")
10241 .assignName("aStem:replaceExisting").assignCreateParentStemsIfNotExist(true).save();
10242
10243 Set<Subject> subjects = grouperSession.getAccessResolver().getSubjectsWithPrivilege(replaceGroup, AccessPrivilege.UPDATE);
10244
10245 assertEquals(0, GrouperUtil.length(subjects));
10246
10247 replaceGroup.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.UPDATE);
10248
10249 GrouperClient
10250 .main(GrouperClientUtils
10251 .splitTrim(
10252 "--operation=assignGrouperPrivilegesWs --groupName=aStem:replaceExisting --privilegeNames=update --allowed=true --subjectIds=test.subject.4 --replaceAllExisting=true",
10253 " "));
10254 System.out.flush();
10255 output = new String(baos.toByteArray());
10256
10257 System.setOut(systemOut);
10258
10259 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10260
10261 matcher = pattern.matcher(outputLines[0]);
10262
10263 assertEquals(GrouperClientUtils.length(outputLines), 1);
10264 assertTrue(outputLines[0], matcher.matches());
10265
10266 assertEquals("0", matcher.group(1));
10267 assertEquals("T", matcher.group(2));
10268 assertEquals("SUCCESS_ALLOWED", matcher.group(3));
10269 assertEquals("group", matcher.group(4));
10270 assertEquals("aStem:replaceExisting", matcher.group(5));
10271 assertEquals("test.subject.4", matcher.group(6));
10272 assertEquals("access", matcher.group(7));
10273 assertEquals("update", matcher.group(8));
10274
10275 subjects = grouperSession.getAccessResolver().getSubjectsWithPrivilege(replaceGroup, AccessPrivilege.UPDATE);
10276
10277 assertEquals(1, GrouperUtil.length(subjects));
10278 assertEquals(SubjectTestHelper.SUBJ4_ID, subjects.iterator().next().getId());
10279 } finally {
10280 System.setOut(systemOut);
10281 }
10282
10283 }
10284
10285
10286
10287
10288 public void testGetAttributeAssignsGroup() throws Exception {
10289
10290 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
10291 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
10292
10293 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
10294
10295 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
10296
10297 attributeDef2.setAssignToGroup(false);
10298 attributeDef2.setAssignToGroupAssn(true);
10299 attributeDef2.store();
10300
10301 Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
10302 .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
10303 .assignDescription("description").save();
10304
10305
10306 group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
10307 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
10308
10309
10310 attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
10311
10312 AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
10313 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
10314
10315 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
10316 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
10317
10318 PrintStream systemOut = System.out;
10319
10320 ByteArrayOutputStream baos = new ByteArrayOutputStream();
10321 System.setOut(new PrintStream(baos));
10322
10323 try {
10324
10325 GrouperClient.main(GrouperClientUtils.splitTrim(
10326 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNames=test:testAttributeAssignDefNameDef",
10327 " "));
10328 System.out.flush();
10329 String output = new String(baos.toByteArray());
10330
10331 System.setOut(systemOut);
10332
10333 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
10334
10335
10336
10337 Pattern pattern = Pattern
10338 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
10339 String outputLine = outputLines[0];
10340
10341 Matcher matcher = pattern.matcher(outputLines[0]);
10342
10343 assertTrue(outputLine, matcher.matches());
10344 assertEquals(outputLine, "0", matcher.group(1));
10345 assertEquals(outputLine, "group", matcher.group(2));
10346 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10347 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10348 assertEquals(outputLine, "assign", matcher.group(5));
10349 assertEquals(outputLine, "none", matcher.group(6));
10350 assertEquals(outputLine, "T", matcher.group(7));
10351 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10352
10353 assertTrue(GrouperClientWs.mostRecentRequest,
10354 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10355 assertTrue(GrouperClientWs.mostRecentRequest,
10356 !GrouperClientWs.mostRecentRequest.contains("actions"));
10357 assertTrue(GrouperClientWs.mostRecentRequest,
10358 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10359 assertTrue(GrouperClientWs.mostRecentRequest,
10360 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10361 assertTrue(GrouperClientWs.mostRecentRequest,
10362 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10363 assertTrue(GrouperClientWs.mostRecentRequest,
10364 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10365 assertTrue(GrouperClientWs.mostRecentRequest,
10366 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10367 assertTrue(GrouperClientWs.mostRecentRequest,
10368 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10369 assertTrue(GrouperClientWs.mostRecentRequest,
10370 !GrouperClientWs.mostRecentRequest.contains("params"));
10371 assertTrue(GrouperClientWs.mostRecentRequest,
10372 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10373 assertTrue(GrouperClientWs.mostRecentRequest,
10374 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10375 assertTrue(GrouperClientWs.mostRecentRequest,
10376 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
10377 assertTrue(GrouperClientWs.mostRecentRequest,
10378 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10379 assertTrue(GrouperClientWs.mostRecentRequest,
10380 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10381 assertTrue(GrouperClientWs.mostRecentRequest,
10382 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10383 assertTrue(GrouperClientWs.mostRecentRequest,
10384 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10385 assertTrue(GrouperClientWs.mostRecentRequest,
10386 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10387 assertTrue(GrouperClientWs.mostRecentRequest,
10388 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10389 assertTrue(GrouperClientWs.mostRecentRequest,
10390 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10391
10392
10393
10394
10395 baos = new ByteArrayOutputStream();
10396 System.setOut(new PrintStream(baos));
10397
10398 GrouperClient.main(GrouperClientUtils.splitTrim(
10399 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId(),
10400 " "));
10401
10402
10403 System.out.flush();
10404 output = new String(baos.toByteArray());
10405
10406 System.setOut(systemOut);
10407
10408 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10409
10410 outputLine = outputLines[0];
10411
10412 matcher = pattern.matcher(outputLines[0]);
10413
10414 assertTrue(outputLine, matcher.matches());
10415 assertEquals(outputLine, "0", matcher.group(1));
10416 assertEquals(outputLine, "group", matcher.group(2));
10417 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10418 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10419 assertEquals(outputLine, "assign", matcher.group(5));
10420 assertEquals(outputLine, "none", matcher.group(6));
10421 assertEquals(outputLine, "T", matcher.group(7));
10422 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10423
10424 assertTrue(GrouperClientWs.mostRecentRequest,
10425 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10426 assertTrue(GrouperClientWs.mostRecentRequest,
10427 !GrouperClientWs.mostRecentRequest.contains("actions"));
10428 assertTrue(GrouperClientWs.mostRecentRequest,
10429 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10430 assertTrue(GrouperClientWs.mostRecentRequest,
10431 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10432 assertTrue(GrouperClientWs.mostRecentRequest,
10433 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10434 assertTrue(GrouperClientWs.mostRecentRequest,
10435 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10436 assertTrue(GrouperClientWs.mostRecentRequest,
10437 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10438 assertTrue(GrouperClientWs.mostRecentRequest,
10439 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10440 assertTrue(GrouperClientWs.mostRecentRequest,
10441 !GrouperClientWs.mostRecentRequest.contains("params"));
10442 assertTrue(GrouperClientWs.mostRecentRequest,
10443 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10444 assertTrue(GrouperClientWs.mostRecentRequest,
10445 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10446 assertTrue(GrouperClientWs.mostRecentRequest,
10447 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
10448 assertTrue(GrouperClientWs.mostRecentRequest,
10449 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10450 assertTrue(GrouperClientWs.mostRecentRequest,
10451 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10452 assertTrue(GrouperClientWs.mostRecentRequest,
10453 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10454 assertTrue(GrouperClientWs.mostRecentRequest,
10455 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10456 assertTrue(GrouperClientWs.mostRecentRequest,
10457 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10458 assertTrue(GrouperClientWs.mostRecentRequest,
10459 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10460 assertTrue(GrouperClientWs.mostRecentRequest,
10461 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10462
10463
10464
10465
10466
10467 baos = new ByteArrayOutputStream();
10468 System.setOut(new PrintStream(baos));
10469
10470 GrouperClient.main(GrouperClientUtils.splitTrim(
10471 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefIdIndexes=" + attributeDef.getIdIndex(),
10472 " "));
10473
10474
10475 System.out.flush();
10476 output = new String(baos.toByteArray());
10477
10478 System.setOut(systemOut);
10479
10480 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10481
10482 outputLine = outputLines[0];
10483
10484 matcher = pattern.matcher(outputLines[0]);
10485
10486 assertTrue(outputLine, matcher.matches());
10487 assertEquals(outputLine, "0", matcher.group(1));
10488 assertEquals(outputLine, "group", matcher.group(2));
10489 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10490 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10491 assertEquals(outputLine, "assign", matcher.group(5));
10492 assertEquals(outputLine, "none", matcher.group(6));
10493 assertEquals(outputLine, "T", matcher.group(7));
10494 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10495
10496 assertTrue(GrouperClientWs.mostRecentRequest,
10497 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10498 assertTrue(GrouperClientWs.mostRecentRequest,
10499 !GrouperClientWs.mostRecentRequest.contains("actions"));
10500 assertTrue(GrouperClientWs.mostRecentRequest,
10501 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10502 assertTrue(GrouperClientWs.mostRecentRequest,
10503 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10504 assertTrue(GrouperClientWs.mostRecentRequest,
10505 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10506 assertTrue(GrouperClientWs.mostRecentRequest,
10507 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10508 assertTrue(GrouperClientWs.mostRecentRequest,
10509 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10510 assertTrue(GrouperClientWs.mostRecentRequest,
10511 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10512 assertTrue(GrouperClientWs.mostRecentRequest,
10513 !GrouperClientWs.mostRecentRequest.contains("params"));
10514 assertTrue(GrouperClientWs.mostRecentRequest,
10515 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10516 assertTrue(GrouperClientWs.mostRecentRequest,
10517 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10518 assertTrue(GrouperClientWs.mostRecentRequest,
10519 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
10520 assertTrue(GrouperClientWs.mostRecentRequest,
10521 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10522 assertTrue(GrouperClientWs.mostRecentRequest,
10523 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10524 assertTrue(GrouperClientWs.mostRecentRequest,
10525 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10526 assertTrue(GrouperClientWs.mostRecentRequest,
10527 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10528 assertTrue(GrouperClientWs.mostRecentRequest,
10529 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10530 assertTrue(GrouperClientWs.mostRecentRequest,
10531 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10532 assertTrue(GrouperClientWs.mostRecentRequest,
10533 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10534
10535
10536
10537
10538
10539 baos = new ByteArrayOutputStream();
10540 System.setOut(new PrintStream(baos));
10541
10542 GrouperClient.main(GrouperClientUtils.splitTrim(
10543 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNameNames=" + attributeDefName.getName(),
10544 " "));
10545
10546
10547 System.out.flush();
10548 output = new String(baos.toByteArray());
10549
10550 System.setOut(systemOut);
10551
10552 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10553
10554 outputLine = outputLines[0];
10555
10556 matcher = pattern.matcher(outputLines[0]);
10557
10558 assertTrue(outputLine, matcher.matches());
10559 assertEquals(outputLine, "0", matcher.group(1));
10560 assertEquals(outputLine, "group", matcher.group(2));
10561 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10562 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10563 assertEquals(outputLine, "assign", matcher.group(5));
10564 assertEquals(outputLine, "none", matcher.group(6));
10565 assertEquals(outputLine, "T", matcher.group(7));
10566 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10567
10568 assertTrue(GrouperClientWs.mostRecentRequest,
10569 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10570 assertTrue(GrouperClientWs.mostRecentRequest,
10571 !GrouperClientWs.mostRecentRequest.contains("actions"));
10572 assertTrue(GrouperClientWs.mostRecentRequest,
10573 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10574 assertTrue(GrouperClientWs.mostRecentRequest,
10575 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10576 assertTrue(GrouperClientWs.mostRecentRequest,
10577 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10578 assertTrue(GrouperClientWs.mostRecentRequest,
10579 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10580 assertTrue(GrouperClientWs.mostRecentRequest,
10581 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10582 assertTrue(GrouperClientWs.mostRecentRequest,
10583 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10584 assertTrue(GrouperClientWs.mostRecentRequest,
10585 !GrouperClientWs.mostRecentRequest.contains("params"));
10586 assertTrue(GrouperClientWs.mostRecentRequest,
10587 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10588 assertTrue(GrouperClientWs.mostRecentRequest,
10589 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10590 assertTrue(GrouperClientWs.mostRecentRequest,
10591 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10592 assertTrue(GrouperClientWs.mostRecentRequest,
10593 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
10594 assertTrue(GrouperClientWs.mostRecentRequest,
10595 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10596 assertTrue(GrouperClientWs.mostRecentRequest,
10597 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10598 assertTrue(GrouperClientWs.mostRecentRequest,
10599 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10600 assertTrue(GrouperClientWs.mostRecentRequest,
10601 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10602 assertTrue(GrouperClientWs.mostRecentRequest,
10603 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10604 assertTrue(GrouperClientWs.mostRecentRequest,
10605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10606
10607
10608
10609
10610
10611
10612 baos = new ByteArrayOutputStream();
10613 System.setOut(new PrintStream(baos));
10614
10615 GrouperClient.main(GrouperClientUtils.splitTrim(
10616 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNameUuids=" + attributeDefName.getId(),
10617 " "));
10618
10619
10620 System.out.flush();
10621 output = new String(baos.toByteArray());
10622
10623 System.setOut(systemOut);
10624
10625 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10626
10627 outputLine = outputLines[0];
10628
10629 matcher = pattern.matcher(outputLines[0]);
10630
10631 assertTrue(outputLine, matcher.matches());
10632 assertEquals(outputLine, "0", matcher.group(1));
10633 assertEquals(outputLine, "group", matcher.group(2));
10634 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10635 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10636 assertEquals(outputLine, "assign", matcher.group(5));
10637 assertEquals(outputLine, "none", matcher.group(6));
10638 assertEquals(outputLine, "T", matcher.group(7));
10639 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10640
10641 assertTrue(GrouperClientWs.mostRecentRequest,
10642 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10643 assertTrue(GrouperClientWs.mostRecentRequest,
10644 !GrouperClientWs.mostRecentRequest.contains("actions"));
10645 assertTrue(GrouperClientWs.mostRecentRequest,
10646 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10647 assertTrue(GrouperClientWs.mostRecentRequest,
10648 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10649 assertTrue(GrouperClientWs.mostRecentRequest,
10650 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10651 assertTrue(GrouperClientWs.mostRecentRequest,
10652 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10653 assertTrue(GrouperClientWs.mostRecentRequest,
10654 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10655 assertTrue(GrouperClientWs.mostRecentRequest,
10656 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10657 assertTrue(GrouperClientWs.mostRecentRequest,
10658 !GrouperClientWs.mostRecentRequest.contains("params"));
10659 assertTrue(GrouperClientWs.mostRecentRequest,
10660 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10661 assertTrue(GrouperClientWs.mostRecentRequest,
10662 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10663 assertTrue(GrouperClientWs.mostRecentRequest,
10664 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10665 assertTrue(GrouperClientWs.mostRecentRequest,
10666 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
10667 assertTrue(GrouperClientWs.mostRecentRequest,
10668 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10669 assertTrue(GrouperClientWs.mostRecentRequest,
10670 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10671 assertTrue(GrouperClientWs.mostRecentRequest,
10672 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10673 assertTrue(GrouperClientWs.mostRecentRequest,
10674 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10675 assertTrue(GrouperClientWs.mostRecentRequest,
10676 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10677 assertTrue(GrouperClientWs.mostRecentRequest,
10678 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10679
10680
10681
10682
10683 baos = new ByteArrayOutputStream();
10684 System.setOut(new PrintStream(baos));
10685
10686 GrouperClient.main(GrouperClientUtils.splitTrim(
10687 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNameIdIndexes=" + attributeDefName.getIdIndex(),
10688 " "));
10689
10690
10691 System.out.flush();
10692 output = new String(baos.toByteArray());
10693
10694 System.setOut(systemOut);
10695
10696 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10697
10698 outputLine = outputLines[0];
10699
10700 matcher = pattern.matcher(outputLines[0]);
10701
10702 assertTrue(outputLine, matcher.matches());
10703 assertEquals(outputLine, "0", matcher.group(1));
10704 assertEquals(outputLine, "group", matcher.group(2));
10705 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10706 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10707 assertEquals(outputLine, "assign", matcher.group(5));
10708 assertEquals(outputLine, "none", matcher.group(6));
10709 assertEquals(outputLine, "T", matcher.group(7));
10710 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10711
10712 assertTrue(GrouperClientWs.mostRecentRequest,
10713 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10714 assertTrue(GrouperClientWs.mostRecentRequest,
10715 !GrouperClientWs.mostRecentRequest.contains("actions"));
10716 assertTrue(GrouperClientWs.mostRecentRequest,
10717 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10718 assertTrue(GrouperClientWs.mostRecentRequest,
10719 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10720 assertTrue(GrouperClientWs.mostRecentRequest,
10721 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10722 assertTrue(GrouperClientWs.mostRecentRequest,
10723 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10724 assertTrue(GrouperClientWs.mostRecentRequest,
10725 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10726 assertTrue(GrouperClientWs.mostRecentRequest,
10727 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10728 assertTrue(GrouperClientWs.mostRecentRequest,
10729 !GrouperClientWs.mostRecentRequest.contains("params"));
10730 assertTrue(GrouperClientWs.mostRecentRequest,
10731 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10732 assertTrue(GrouperClientWs.mostRecentRequest,
10733 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10734 assertTrue(GrouperClientWs.mostRecentRequest,
10735 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10736 assertTrue(GrouperClientWs.mostRecentRequest,
10737 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
10738 assertTrue(GrouperClientWs.mostRecentRequest,
10739 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10740 assertTrue(GrouperClientWs.mostRecentRequest,
10741 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10742 assertTrue(GrouperClientWs.mostRecentRequest,
10743 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10744 assertTrue(GrouperClientWs.mostRecentRequest,
10745 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10746 assertTrue(GrouperClientWs.mostRecentRequest,
10747 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10748 assertTrue(GrouperClientWs.mostRecentRequest,
10749 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10750
10751
10752
10753
10754
10755 baos = new ByteArrayOutputStream();
10756 System.setOut(new PrintStream(baos));
10757
10758 GrouperClient.main(GrouperClientUtils.splitTrim(
10759 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupNames=" + group.getName(),
10760 " "));
10761
10762
10763 System.out.flush();
10764 output = new String(baos.toByteArray());
10765
10766 System.setOut(systemOut);
10767
10768 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10769
10770 outputLine = outputLines[0];
10771
10772 matcher = pattern.matcher(outputLines[0]);
10773
10774 assertTrue(outputLine, matcher.matches());
10775 assertEquals(outputLine, "0", matcher.group(1));
10776 assertEquals(outputLine, "group", matcher.group(2));
10777 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10778 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10779 assertEquals(outputLine, "assign", matcher.group(5));
10780 assertEquals(outputLine, "none", matcher.group(6));
10781 assertEquals(outputLine, "T", matcher.group(7));
10782 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10783
10784 assertTrue(GrouperClientWs.mostRecentRequest,
10785 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10786 assertTrue(GrouperClientWs.mostRecentRequest,
10787 !GrouperClientWs.mostRecentRequest.contains("actions"));
10788 assertTrue(GrouperClientWs.mostRecentRequest,
10789 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10790 assertTrue(GrouperClientWs.mostRecentRequest,
10791 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10792 assertTrue(GrouperClientWs.mostRecentRequest,
10793 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10794 assertTrue(GrouperClientWs.mostRecentRequest,
10795 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10796 assertTrue(GrouperClientWs.mostRecentRequest,
10797 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10798 assertTrue(GrouperClientWs.mostRecentRequest,
10799 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10800 assertTrue(GrouperClientWs.mostRecentRequest,
10801 !GrouperClientWs.mostRecentRequest.contains("params"));
10802 assertTrue(GrouperClientWs.mostRecentRequest,
10803 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10804 assertTrue(GrouperClientWs.mostRecentRequest,
10805 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10806 assertTrue(GrouperClientWs.mostRecentRequest,
10807 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10808 assertTrue(GrouperClientWs.mostRecentRequest,
10809 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10810 assertTrue(GrouperClientWs.mostRecentRequest,
10811 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10812 assertTrue(GrouperClientWs.mostRecentRequest,
10813 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10814 assertTrue(GrouperClientWs.mostRecentRequest,
10815 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10816 assertTrue(GrouperClientWs.mostRecentRequest,
10817 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10818 assertTrue(GrouperClientWs.mostRecentRequest,
10819 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10820 assertTrue(GrouperClientWs.mostRecentRequest,
10821 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10822
10823
10824
10825
10826
10827
10828
10829 baos = new ByteArrayOutputStream();
10830 System.setOut(new PrintStream(baos));
10831
10832 GrouperClient.main(GrouperClientUtils.splitTrim(
10833 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId(),
10834 " "));
10835
10836
10837 System.out.flush();
10838 output = new String(baos.toByteArray());
10839
10840 System.setOut(systemOut);
10841
10842 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10843
10844 outputLine = outputLines[0];
10845
10846 matcher = pattern.matcher(outputLines[0]);
10847
10848 assertTrue(outputLine, matcher.matches());
10849 assertEquals(outputLine, "0", matcher.group(1));
10850 assertEquals(outputLine, "group", matcher.group(2));
10851 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10852 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10853 assertEquals(outputLine, "assign", matcher.group(5));
10854 assertEquals(outputLine, "none", matcher.group(6));
10855 assertEquals(outputLine, "T", matcher.group(7));
10856 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10857
10858 assertTrue(GrouperClientWs.mostRecentRequest,
10859 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10860 assertTrue(GrouperClientWs.mostRecentRequest,
10861 !GrouperClientWs.mostRecentRequest.contains("actions"));
10862 assertTrue(GrouperClientWs.mostRecentRequest,
10863 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10864 assertTrue(GrouperClientWs.mostRecentRequest,
10865 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10866 assertTrue(GrouperClientWs.mostRecentRequest,
10867 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10868 assertTrue(GrouperClientWs.mostRecentRequest,
10869 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10870 assertTrue(GrouperClientWs.mostRecentRequest,
10871 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10872 assertTrue(GrouperClientWs.mostRecentRequest,
10873 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10874 assertTrue(GrouperClientWs.mostRecentRequest,
10875 !GrouperClientWs.mostRecentRequest.contains("params"));
10876 assertTrue(GrouperClientWs.mostRecentRequest,
10877 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10878 assertTrue(GrouperClientWs.mostRecentRequest,
10879 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10880 assertTrue(GrouperClientWs.mostRecentRequest,
10881 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10882 assertTrue(GrouperClientWs.mostRecentRequest,
10883 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10884 assertTrue(GrouperClientWs.mostRecentRequest,
10885 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10886 assertTrue(GrouperClientWs.mostRecentRequest,
10887 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10888 assertTrue(GrouperClientWs.mostRecentRequest,
10889 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10890 assertTrue(GrouperClientWs.mostRecentRequest,
10891 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10892 assertTrue(GrouperClientWs.mostRecentRequest,
10893 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10894 assertTrue(GrouperClientWs.mostRecentRequest,
10895 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10896
10897
10898
10899
10900
10901 baos = new ByteArrayOutputStream();
10902 System.setOut(new PrintStream(baos));
10903
10904 GrouperClient.main(GrouperClientUtils.splitTrim(
10905 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupIdIndexes=" + group.getIdIndex(),
10906 " "));
10907
10908
10909 System.out.flush();
10910 output = new String(baos.toByteArray());
10911
10912 System.setOut(systemOut);
10913
10914 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10915
10916 outputLine = outputLines[0];
10917
10918 matcher = pattern.matcher(outputLines[0]);
10919
10920 assertTrue(outputLine, matcher.matches());
10921 assertEquals(outputLine, "0", matcher.group(1));
10922 assertEquals(outputLine, "group", matcher.group(2));
10923 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10924 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10925 assertEquals(outputLine, "assign", matcher.group(5));
10926 assertEquals(outputLine, "none", matcher.group(6));
10927 assertEquals(outputLine, "T", matcher.group(7));
10928 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10929
10930 assertTrue(GrouperClientWs.mostRecentRequest,
10931 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10932 assertTrue(GrouperClientWs.mostRecentRequest,
10933 !GrouperClientWs.mostRecentRequest.contains("actions"));
10934 assertTrue(GrouperClientWs.mostRecentRequest,
10935 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10936 assertTrue(GrouperClientWs.mostRecentRequest,
10937 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10938 assertTrue(GrouperClientWs.mostRecentRequest,
10939 !GrouperClientWs.mostRecentRequest.contains("enabled"));
10940 assertTrue(GrouperClientWs.mostRecentRequest,
10941 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10942 assertTrue(GrouperClientWs.mostRecentRequest,
10943 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10944 assertTrue(GrouperClientWs.mostRecentRequest,
10945 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10946 assertTrue(GrouperClientWs.mostRecentRequest,
10947 !GrouperClientWs.mostRecentRequest.contains("params"));
10948 assertTrue(GrouperClientWs.mostRecentRequest,
10949 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10950 assertTrue(GrouperClientWs.mostRecentRequest,
10951 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10952 assertTrue(GrouperClientWs.mostRecentRequest,
10953 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10954 assertTrue(GrouperClientWs.mostRecentRequest,
10955 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10956 assertTrue(GrouperClientWs.mostRecentRequest,
10957 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10958 assertTrue(GrouperClientWs.mostRecentRequest,
10959 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10960 assertTrue(GrouperClientWs.mostRecentRequest,
10961 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10962 assertTrue(GrouperClientWs.mostRecentRequest,
10963 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10964 assertTrue(GrouperClientWs.mostRecentRequest,
10965 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10966 assertTrue(GrouperClientWs.mostRecentRequest,
10967 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10968
10969
10970
10971
10972
10973
10974 baos = new ByteArrayOutputStream();
10975 System.setOut(new PrintStream(baos));
10976
10977 GrouperClient.main(GrouperClientUtils.splitTrim(
10978 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
10979 + " --enabled=F",
10980 " "));
10981
10982
10983 System.out.flush();
10984 output = new String(baos.toByteArray());
10985
10986 System.setOut(systemOut);
10987
10988 outputLines = GrouperClientUtils.splitTrim(output, "\n");
10989
10990 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
10991
10992 assertTrue(GrouperClientWs.mostRecentRequest,
10993 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10994 assertTrue(GrouperClientWs.mostRecentRequest,
10995 !GrouperClientWs.mostRecentRequest.contains("actions"));
10996 assertTrue(GrouperClientWs.mostRecentRequest,
10997 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10998 assertTrue(GrouperClientWs.mostRecentRequest,
10999 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11000 assertTrue(GrouperClientWs.mostRecentRequest,
11001 GrouperClientWs.mostRecentRequest.contains("enabled"));
11002 assertTrue(GrouperClientWs.mostRecentRequest,
11003 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11004 assertTrue(GrouperClientWs.mostRecentRequest,
11005 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11006 assertTrue(GrouperClientWs.mostRecentRequest,
11007 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11008 assertTrue(GrouperClientWs.mostRecentRequest,
11009 !GrouperClientWs.mostRecentRequest.contains("params"));
11010 assertTrue(GrouperClientWs.mostRecentRequest,
11011 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11012 assertTrue(GrouperClientWs.mostRecentRequest,
11013 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11014 assertTrue(GrouperClientWs.mostRecentRequest,
11015 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11016 assertTrue(GrouperClientWs.mostRecentRequest,
11017 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11018 assertTrue(GrouperClientWs.mostRecentRequest,
11019 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11020 assertTrue(GrouperClientWs.mostRecentRequest,
11021 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11022 assertTrue(GrouperClientWs.mostRecentRequest,
11023 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11024 assertTrue(GrouperClientWs.mostRecentRequest,
11025 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11026 assertTrue(GrouperClientWs.mostRecentRequest,
11027 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11028 assertTrue(GrouperClientWs.mostRecentRequest,
11029 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11030
11031
11032
11033
11034
11035 baos = new ByteArrayOutputStream();
11036 System.setOut(new PrintStream(baos));
11037
11038 GrouperClient.main(GrouperClientUtils.splitTrim(
11039 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11040 + " --actions=a",
11041 " "));
11042
11043
11044 System.out.flush();
11045 output = new String(baos.toByteArray());
11046
11047 System.setOut(systemOut);
11048
11049 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11050
11051 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
11052
11053 assertTrue(GrouperClientWs.mostRecentRequest,
11054 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11055 assertTrue(GrouperClientWs.mostRecentRequest,
11056 GrouperClientWs.mostRecentRequest.contains("actions"));
11057 assertTrue(GrouperClientWs.mostRecentRequest,
11058 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11059 assertTrue(GrouperClientWs.mostRecentRequest,
11060 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11061 assertTrue(GrouperClientWs.mostRecentRequest,
11062 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11063 assertTrue(GrouperClientWs.mostRecentRequest,
11064 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11065 assertTrue(GrouperClientWs.mostRecentRequest,
11066 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11067 assertTrue(GrouperClientWs.mostRecentRequest,
11068 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11069 assertTrue(GrouperClientWs.mostRecentRequest,
11070 !GrouperClientWs.mostRecentRequest.contains("params"));
11071 assertTrue(GrouperClientWs.mostRecentRequest,
11072 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11073 assertTrue(GrouperClientWs.mostRecentRequest,
11074 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11075 assertTrue(GrouperClientWs.mostRecentRequest,
11076 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11077 assertTrue(GrouperClientWs.mostRecentRequest,
11078 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11079 assertTrue(GrouperClientWs.mostRecentRequest,
11080 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11081 assertTrue(GrouperClientWs.mostRecentRequest,
11082 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11083 assertTrue(GrouperClientWs.mostRecentRequest,
11084 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11085 assertTrue(GrouperClientWs.mostRecentRequest,
11086 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11087 assertTrue(GrouperClientWs.mostRecentRequest,
11088 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11089 assertTrue(GrouperClientWs.mostRecentRequest,
11090 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11091
11092
11093
11094
11095
11096 baos = new ByteArrayOutputStream();
11097 System.setOut(new PrintStream(baos));
11098
11099 GrouperClient.main(GrouperClientUtils.splitTrim(
11100 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11101 + " --includeAssignmentsOnAssignments=T",
11102 " "));
11103
11104
11105 System.out.flush();
11106 output = new String(baos.toByteArray());
11107
11108 System.setOut(systemOut);
11109
11110 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11111
11112
11113
11114 outputLine = outputLines[0];
11115
11116 matcher = pattern.matcher(outputLine);
11117
11118 assertTrue(outputLine, matcher.matches());
11119 assertEquals(outputLine, "0", matcher.group(1));
11120 assertEquals(outputLine, "group", matcher.group(2));
11121 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11122 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11123 assertEquals(outputLine, "assign", matcher.group(5));
11124 assertEquals(outputLine, "none", matcher.group(6));
11125 assertEquals(outputLine, "T", matcher.group(7));
11126 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11127
11128 outputLine = outputLines[1];
11129
11130 matcher = pattern.matcher(outputLine);
11131
11132
11133
11134
11135 assertTrue(outputLine, matcher.matches());
11136 assertEquals(outputLine, "1", matcher.group(1));
11137 assertEquals(outputLine, "group_asgn", matcher.group(2));
11138 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
11139 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
11140 assertEquals(outputLine, "assign", matcher.group(5));
11141 assertEquals(outputLine, "none", matcher.group(6));
11142 assertEquals(outputLine, "T", matcher.group(7));
11143 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
11144
11145 assertTrue(GrouperClientWs.mostRecentRequest,
11146 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11147 assertTrue(GrouperClientWs.mostRecentRequest,
11148 !GrouperClientWs.mostRecentRequest.contains("actions"));
11149 assertTrue(GrouperClientWs.mostRecentRequest,
11150 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11151 assertTrue(GrouperClientWs.mostRecentRequest,
11152 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11153 assertTrue(GrouperClientWs.mostRecentRequest,
11154 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11155 assertTrue(GrouperClientWs.mostRecentRequest,
11156 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11157 assertTrue(GrouperClientWs.mostRecentRequest,
11158 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11159 assertTrue(GrouperClientWs.mostRecentRequest,
11160 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11161 assertTrue(GrouperClientWs.mostRecentRequest,
11162 !GrouperClientWs.mostRecentRequest.contains("params"));
11163 assertTrue(GrouperClientWs.mostRecentRequest,
11164 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11165 assertTrue(GrouperClientWs.mostRecentRequest,
11166 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11167 assertTrue(GrouperClientWs.mostRecentRequest,
11168 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11169 assertTrue(GrouperClientWs.mostRecentRequest,
11170 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11171 assertTrue(GrouperClientWs.mostRecentRequest,
11172 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11173 assertTrue(GrouperClientWs.mostRecentRequest,
11174 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11175 assertTrue(GrouperClientWs.mostRecentRequest,
11176 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11177 assertTrue(GrouperClientWs.mostRecentRequest,
11178 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11179 assertTrue(GrouperClientWs.mostRecentRequest,
11180 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11181 assertTrue(GrouperClientWs.mostRecentRequest,
11182 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11183
11184
11185
11186
11187
11188
11189
11190 baos = new ByteArrayOutputStream();
11191 System.setOut(new PrintStream(baos));
11192
11193 GrouperClient.main(GrouperClientUtils.splitTrim(
11194 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11195 + " --includeGroupDetail=T",
11196 " "));
11197
11198
11199 System.out.flush();
11200 output = new String(baos.toByteArray());
11201
11202 System.setOut(systemOut);
11203
11204 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11205
11206 outputLine = outputLines[0];
11207
11208 matcher = pattern.matcher(outputLines[0]);
11209
11210 assertTrue(outputLine, matcher.matches());
11211 assertEquals(outputLine, "0", matcher.group(1));
11212 assertEquals(outputLine, "group", matcher.group(2));
11213 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11214 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11215 assertEquals(outputLine, "assign", matcher.group(5));
11216 assertEquals(outputLine, "none", matcher.group(6));
11217 assertEquals(outputLine, "T", matcher.group(7));
11218 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11219
11220 assertTrue(GrouperClientWs.mostRecentRequest,
11221 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11222 assertTrue(GrouperClientWs.mostRecentRequest,
11223 !GrouperClientWs.mostRecentRequest.contains("actions"));
11224 assertTrue(GrouperClientWs.mostRecentRequest,
11225 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11226 assertTrue(GrouperClientWs.mostRecentRequest,
11227 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11228 assertTrue(GrouperClientWs.mostRecentRequest,
11229 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11230 assertTrue(GrouperClientWs.mostRecentRequest,
11231 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11232 assertTrue(GrouperClientWs.mostRecentRequest,
11233 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11234 assertTrue(GrouperClientWs.mostRecentRequest,
11235 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11236 assertTrue(GrouperClientWs.mostRecentRequest,
11237 !GrouperClientWs.mostRecentRequest.contains("params"));
11238 assertTrue(GrouperClientWs.mostRecentRequest,
11239 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11240 assertTrue(GrouperClientWs.mostRecentRequest,
11241 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11242 assertTrue(GrouperClientWs.mostRecentRequest,
11243 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11244 assertTrue(GrouperClientWs.mostRecentRequest,
11245 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11246 assertTrue(GrouperClientWs.mostRecentRequest,
11247 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11248 assertTrue(GrouperClientWs.mostRecentRequest,
11249 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11250 assertTrue(GrouperClientWs.mostRecentRequest,
11251 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11252 assertTrue(GrouperClientWs.mostRecentRequest,
11253 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11254 assertTrue(GrouperClientWs.mostRecentRequest,
11255 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11256 assertTrue(GrouperClientWs.mostRecentRequest,
11257 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11258 assertTrue(GrouperClientWs.mostRecentResponse,
11259 GrouperClientWs.mostRecentResponse.contains("hasComposite"));
11260
11261
11262
11263
11264
11265
11266
11267 baos = new ByteArrayOutputStream();
11268 System.setOut(new PrintStream(baos));
11269
11270 GrouperClient.main(GrouperClientUtils.splitTrim(
11271 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11272 + " --includeSubjectDetail=T",
11273 " "));
11274
11275
11276 System.out.flush();
11277 output = new String(baos.toByteArray());
11278
11279 System.setOut(systemOut);
11280
11281 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11282
11283 outputLine = outputLines[0];
11284
11285 matcher = pattern.matcher(outputLines[0]);
11286
11287 assertTrue(outputLine, matcher.matches());
11288 assertEquals(outputLine, "0", matcher.group(1));
11289 assertEquals(outputLine, "group", matcher.group(2));
11290 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11291 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11292 assertEquals(outputLine, "assign", matcher.group(5));
11293 assertEquals(outputLine, "none", matcher.group(6));
11294 assertEquals(outputLine, "T", matcher.group(7));
11295 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11296
11297 assertTrue(GrouperClientWs.mostRecentRequest,
11298 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11299 assertTrue(GrouperClientWs.mostRecentRequest,
11300 !GrouperClientWs.mostRecentRequest.contains("actions"));
11301 assertTrue(GrouperClientWs.mostRecentRequest,
11302 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11303 assertTrue(GrouperClientWs.mostRecentRequest,
11304 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11305 assertTrue(GrouperClientWs.mostRecentRequest,
11306 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11307 assertTrue(GrouperClientWs.mostRecentRequest,
11308 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11309 assertTrue(GrouperClientWs.mostRecentRequest,
11310 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11311 assertTrue(GrouperClientWs.mostRecentRequest,
11312 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11313 assertTrue(GrouperClientWs.mostRecentRequest,
11314 !GrouperClientWs.mostRecentRequest.contains("params"));
11315 assertTrue(GrouperClientWs.mostRecentRequest,
11316 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11317 assertTrue(GrouperClientWs.mostRecentRequest,
11318 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11319 assertTrue(GrouperClientWs.mostRecentRequest,
11320 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11321 assertTrue(GrouperClientWs.mostRecentRequest,
11322 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11323 assertTrue(GrouperClientWs.mostRecentRequest,
11324 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11325 assertTrue(GrouperClientWs.mostRecentRequest,
11326 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11327 assertTrue(GrouperClientWs.mostRecentRequest,
11328 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11329 assertTrue(GrouperClientWs.mostRecentRequest,
11330 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11331 assertTrue(GrouperClientWs.mostRecentRequest,
11332 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11333 assertTrue(GrouperClientWs.mostRecentRequest,
11334 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11335
11336
11337
11338
11339
11340
11341
11342
11343 baos = new ByteArrayOutputStream();
11344 System.setOut(new PrintStream(baos));
11345
11346 GrouperClient.main(GrouperClientUtils.splitTrim(
11347 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11348 + " --subjectAttributeNames=abc",
11349 " "));
11350
11351
11352 System.out.flush();
11353 output = new String(baos.toByteArray());
11354
11355 System.setOut(systemOut);
11356
11357 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11358
11359 outputLine = outputLines[0];
11360
11361 matcher = pattern.matcher(outputLines[0]);
11362
11363 assertTrue(outputLine, matcher.matches());
11364 assertEquals(outputLine, "0", matcher.group(1));
11365 assertEquals(outputLine, "group", matcher.group(2));
11366 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11367 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11368 assertEquals(outputLine, "assign", matcher.group(5));
11369 assertEquals(outputLine, "none", matcher.group(6));
11370 assertEquals(outputLine, "T", matcher.group(7));
11371 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11372
11373 assertTrue(GrouperClientWs.mostRecentRequest,
11374 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11375 assertTrue(GrouperClientWs.mostRecentRequest,
11376 !GrouperClientWs.mostRecentRequest.contains("actions"));
11377 assertTrue(GrouperClientWs.mostRecentRequest,
11378 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11379 assertTrue(GrouperClientWs.mostRecentRequest,
11380 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11381 assertTrue(GrouperClientWs.mostRecentRequest,
11382 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11383 assertTrue(GrouperClientWs.mostRecentRequest,
11384 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11385 assertTrue(GrouperClientWs.mostRecentRequest,
11386 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11387 assertTrue(GrouperClientWs.mostRecentRequest,
11388 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11389 assertTrue(GrouperClientWs.mostRecentRequest,
11390 !GrouperClientWs.mostRecentRequest.contains("params"));
11391 assertTrue(GrouperClientWs.mostRecentRequest,
11392 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames")
11393 && GrouperClientWs.mostRecentRequest.contains("abc"));
11394 assertTrue(GrouperClientWs.mostRecentRequest,
11395 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11396 assertTrue(GrouperClientWs.mostRecentRequest,
11397 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11398 assertTrue(GrouperClientWs.mostRecentRequest,
11399 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11400 assertTrue(GrouperClientWs.mostRecentRequest,
11401 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11402 assertTrue(GrouperClientWs.mostRecentRequest,
11403 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11404 assertTrue(GrouperClientWs.mostRecentRequest,
11405 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11406 assertTrue(GrouperClientWs.mostRecentRequest,
11407 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11408 assertTrue(GrouperClientWs.mostRecentRequest,
11409 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11410 assertTrue(GrouperClientWs.mostRecentRequest,
11411 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11412
11413
11414
11415
11416
11417
11418
11419 baos = new ByteArrayOutputStream();
11420 System.setOut(new PrintStream(baos));
11421
11422 GrouperClient.main(GrouperClientUtils.splitTrim(
11423 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11424 + " --paramName0=a --paramValue0=b",
11425 " "));
11426
11427
11428 System.out.flush();
11429 output = new String(baos.toByteArray());
11430
11431 System.setOut(systemOut);
11432
11433 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11434
11435 outputLine = outputLines[0];
11436
11437 matcher = pattern.matcher(outputLines[0]);
11438
11439 assertTrue(outputLine, matcher.matches());
11440 assertEquals(outputLine, "0", matcher.group(1));
11441 assertEquals(outputLine, "group", matcher.group(2));
11442 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11443 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11444 assertEquals(outputLine, "assign", matcher.group(5));
11445 assertEquals(outputLine, "none", matcher.group(6));
11446 assertEquals(outputLine, "T", matcher.group(7));
11447 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11448
11449 assertTrue(GrouperClientWs.mostRecentRequest,
11450 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11451 assertTrue(GrouperClientWs.mostRecentRequest,
11452 !GrouperClientWs.mostRecentRequest.contains("actions"));
11453 assertTrue(GrouperClientWs.mostRecentRequest,
11454 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11455 assertTrue(GrouperClientWs.mostRecentRequest,
11456 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11457 assertTrue(GrouperClientWs.mostRecentRequest,
11458 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11459 assertTrue(GrouperClientWs.mostRecentRequest,
11460 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11461 assertTrue(GrouperClientWs.mostRecentRequest,
11462 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11463 assertTrue(GrouperClientWs.mostRecentRequest,
11464 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11465 assertTrue(GrouperClientWs.mostRecentRequest,
11466 GrouperClientWs.mostRecentRequest.contains("params"));
11467 assertTrue(GrouperClientWs.mostRecentRequest,
11468 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11469 assertTrue(GrouperClientWs.mostRecentRequest,
11470 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11471 assertTrue(GrouperClientWs.mostRecentRequest,
11472 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11473 assertTrue(GrouperClientWs.mostRecentRequest,
11474 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11475 assertTrue(GrouperClientWs.mostRecentRequest,
11476 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11477 assertTrue(GrouperClientWs.mostRecentRequest,
11478 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11479 assertTrue(GrouperClientWs.mostRecentRequest,
11480 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11481 assertTrue(GrouperClientWs.mostRecentRequest,
11482 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11483 assertTrue(GrouperClientWs.mostRecentRequest,
11484 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11485 assertTrue(GrouperClientWs.mostRecentRequest,
11486 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11487
11488
11489
11490
11491
11492
11493 baos = new ByteArrayOutputStream();
11494 System.setOut(new PrintStream(baos));
11495
11496 GrouperClient.main(GrouperClientUtils.splitTrim(
11497 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeAssignUuids=" + attributeAssign.getId(),
11498 " "));
11499
11500
11501 System.out.flush();
11502 output = new String(baos.toByteArray());
11503
11504 System.setOut(systemOut);
11505
11506 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11507
11508 outputLine = outputLines[0];
11509
11510 matcher = pattern.matcher(outputLines[0]);
11511
11512 assertTrue(outputLine, matcher.matches());
11513 assertEquals(outputLine, "0", matcher.group(1));
11514 assertEquals(outputLine, "group", matcher.group(2));
11515 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11516 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11517 assertEquals(outputLine, "assign", matcher.group(5));
11518 assertEquals(outputLine, "none", matcher.group(6));
11519 assertEquals(outputLine, "T", matcher.group(7));
11520 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11521
11522 assertTrue(GrouperClientWs.mostRecentRequest,
11523 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11524 assertTrue(GrouperClientWs.mostRecentRequest,
11525 !GrouperClientWs.mostRecentRequest.contains("actions"));
11526 assertTrue(GrouperClientWs.mostRecentRequest,
11527 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11528 assertTrue(GrouperClientWs.mostRecentRequest,
11529 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11530 assertTrue(GrouperClientWs.mostRecentRequest,
11531 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11532 assertTrue(GrouperClientWs.mostRecentRequest,
11533 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11534 assertTrue(GrouperClientWs.mostRecentRequest,
11535 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11536 assertTrue(GrouperClientWs.mostRecentRequest,
11537 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11538 assertTrue(GrouperClientWs.mostRecentRequest,
11539 !GrouperClientWs.mostRecentRequest.contains("params"));
11540 assertTrue(GrouperClientWs.mostRecentRequest,
11541 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11542 assertTrue(GrouperClientWs.mostRecentRequest,
11543 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11544 assertTrue(GrouperClientWs.mostRecentRequest,
11545 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11546 assertTrue(GrouperClientWs.mostRecentRequest,
11547 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11548 assertTrue(GrouperClientWs.mostRecentRequest,
11549 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11550 assertTrue(GrouperClientWs.mostRecentRequest,
11551 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11552 assertTrue(GrouperClientWs.mostRecentRequest,
11553 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11554 assertTrue(GrouperClientWs.mostRecentRequest,
11555 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11556 assertTrue(GrouperClientWs.mostRecentRequest,
11557 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11558 assertTrue(GrouperClientWs.mostRecentRequest,
11559 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11560
11561
11562
11563
11564
11565
11566 baos = new ByteArrayOutputStream();
11567 System.setOut(new PrintStream(baos));
11568
11569 GrouperClient.main(GrouperClientUtils.splitTrim(
11570 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeAssignUuids=" + attributeAssign.getId()
11571 + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
11572 " "));
11573
11574
11575 System.out.flush();
11576 output = new String(baos.toByteArray());
11577
11578 System.setOut(systemOut);
11579
11580 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11581
11582 outputLine = GrouperClientUtils.trim(outputLines[0]);
11583
11584 assertEquals(outputLine, "group", outputLine);
11585
11586 assertTrue(GrouperClientWs.mostRecentRequest,
11587 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11588 assertTrue(GrouperClientWs.mostRecentRequest,
11589 !GrouperClientWs.mostRecentRequest.contains("actions"));
11590 assertTrue(GrouperClientWs.mostRecentRequest,
11591 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11592 assertTrue(GrouperClientWs.mostRecentRequest,
11593 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11594 assertTrue(GrouperClientWs.mostRecentRequest,
11595 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11596 assertTrue(GrouperClientWs.mostRecentRequest,
11597 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11598 assertTrue(GrouperClientWs.mostRecentRequest,
11599 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11600 assertTrue(GrouperClientWs.mostRecentRequest,
11601 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11602 assertTrue(GrouperClientWs.mostRecentRequest,
11603 !GrouperClientWs.mostRecentRequest.contains("params"));
11604 assertTrue(GrouperClientWs.mostRecentRequest,
11605 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11606 assertTrue(GrouperClientWs.mostRecentRequest,
11607 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11608 assertTrue(GrouperClientWs.mostRecentRequest,
11609 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11610 assertTrue(GrouperClientWs.mostRecentRequest,
11611 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11612 assertTrue(GrouperClientWs.mostRecentRequest,
11613 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11614 assertTrue(GrouperClientWs.mostRecentRequest,
11615 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11616 assertTrue(GrouperClientWs.mostRecentRequest,
11617 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11618 assertTrue(GrouperClientWs.mostRecentRequest,
11619 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11620 assertTrue(GrouperClientWs.mostRecentRequest,
11621 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11622 assertTrue(GrouperClientWs.mostRecentRequest,
11623 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11624
11625
11626
11627
11628
11629 baos = new ByteArrayOutputStream();
11630 System.setOut(new PrintStream(baos));
11631
11632 GrouperClient.main(GrouperClientUtils.splitTrim(
11633 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeAssignUuids=" + attributeAssign.getId()
11634 + " --actAsSubjectId=GrouperSystem",
11635 " "));
11636
11637
11638 System.out.flush();
11639 output = new String(baos.toByteArray());
11640
11641 System.setOut(systemOut);
11642
11643 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11644
11645 outputLine = outputLines[0];
11646
11647 matcher = pattern.matcher(outputLines[0]);
11648
11649 assertTrue(outputLine, matcher.matches());
11650 assertEquals(outputLine, "0", matcher.group(1));
11651 assertEquals(outputLine, "group", matcher.group(2));
11652 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11653 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11654 assertEquals(outputLine, "assign", matcher.group(5));
11655 assertEquals(outputLine, "none", matcher.group(6));
11656 assertEquals(outputLine, "T", matcher.group(7));
11657 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11658
11659 assertTrue(GrouperClientWs.mostRecentRequest,
11660 GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11661 assertTrue(GrouperClientWs.mostRecentRequest,
11662 !GrouperClientWs.mostRecentRequest.contains("actions"));
11663 assertTrue(GrouperClientWs.mostRecentRequest,
11664 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11665 assertTrue(GrouperClientWs.mostRecentRequest,
11666 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11667 assertTrue(GrouperClientWs.mostRecentRequest,
11668 !GrouperClientWs.mostRecentRequest.contains("enabled"));
11669 assertTrue(GrouperClientWs.mostRecentRequest,
11670 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11671 assertTrue(GrouperClientWs.mostRecentRequest,
11672 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11673 assertTrue(GrouperClientWs.mostRecentRequest,
11674 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11675 assertTrue(GrouperClientWs.mostRecentRequest,
11676 !GrouperClientWs.mostRecentRequest.contains("params"));
11677 assertTrue(GrouperClientWs.mostRecentRequest,
11678 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11679 assertTrue(GrouperClientWs.mostRecentRequest,
11680 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11681 assertTrue(GrouperClientWs.mostRecentRequest,
11682 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11683 assertTrue(GrouperClientWs.mostRecentRequest,
11684 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11685 assertTrue(GrouperClientWs.mostRecentRequest,
11686 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11687 assertTrue(GrouperClientWs.mostRecentRequest,
11688 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11689 assertTrue(GrouperClientWs.mostRecentRequest,
11690 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11691 assertTrue(GrouperClientWs.mostRecentRequest,
11692 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11693 assertTrue(GrouperClientWs.mostRecentRequest,
11694 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11695 assertTrue(GrouperClientWs.mostRecentRequest,
11696 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11697
11698
11699
11700
11701
11702 } finally {
11703 System.setOut(systemOut);
11704 }
11705
11706 }
11707
11708
11709
11710
11711 public void testGetAttributeAssignActions() throws Exception {
11712
11713 AttributeDefName nameOfAttributeDef = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
11714
11715 final AttributeDef attributeDef = nameOfAttributeDef.getAttributeDef();
11716 attributeDef.getAttributeDefActionDelegate().addAction("read");
11717 attributeDef.store();
11718
11719 PrintStream systemOut = System.out;
11720
11721 ByteArrayOutputStream baos = new ByteArrayOutputStream();
11722 System.setOut(new PrintStream(baos));
11723
11724 try {
11725
11726 GrouperClient.main(GrouperClientUtils.splitTrim(
11727 "--operation=getAttributeAssignActionsWs --namesOfAttributeDefs=test:testAttributeAssignDefNameDef",
11728 " "));
11729 System.out.flush();
11730 String output = new String(baos.toByteArray());
11731
11732 System.setOut(systemOut);
11733
11734 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
11735
11736 Pattern pattern = Pattern
11737 .compile("^Index: (\\d+)\\: nameOfAttributeDef\\: (.+), action: (.+)$");
11738 String outputLine = outputLines[0];
11739
11740 Matcher matcher = pattern.matcher(outputLines[0]);
11741
11742 assertTrue(outputLine, matcher.matches());
11743 assertEquals(outputLine, "0", matcher.group(1));
11744 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11745 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11746
11747 outputLine = outputLines[1];
11748 matcher = pattern.matcher(outputLines[1]);
11749
11750 assertTrue(outputLine, matcher.matches());
11751 assertEquals(outputLine, "1", matcher.group(1));
11752 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11753 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11754
11755 assertTrue(GrouperClientWs.mostRecentRequest,
11756 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11757 assertTrue(GrouperClientWs.mostRecentRequest,
11758 !GrouperClientWs.mostRecentRequest.contains("actions"));
11759 assertTrue(GrouperClientWs.mostRecentRequest,
11760 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11761 assertTrue(GrouperClientWs.mostRecentRequest,
11762 !GrouperClientWs.mostRecentRequest.contains("params"));
11763 assertTrue(GrouperClientWs.mostRecentRequest,
11764 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
11765 assertTrue(GrouperClientWs.mostRecentRequest,
11766 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11767
11768
11769
11770
11771 baos = new ByteArrayOutputStream();
11772 System.setOut(new PrintStream(baos));
11773
11774 GrouperClient.main(GrouperClientUtils.splitTrim(
11775 "--operation=getAttributeAssignActionsWs --uuidsOfAttributeDefs=" + attributeDef.getId(),
11776 " "));
11777
11778
11779 System.out.flush();
11780 output = new String(baos.toByteArray());
11781
11782 System.setOut(systemOut);
11783
11784 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11785
11786 outputLine = outputLines[0];
11787
11788 matcher = pattern.matcher(outputLines[0]);
11789
11790 assertTrue(outputLine, matcher.matches());
11791 assertEquals(outputLine, "0", matcher.group(1));
11792 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11793 assertEquals(outputLine, "read", matcher.group(3));
11794
11795 outputLine = outputLines[1];
11796 matcher = pattern.matcher(outputLines[1]);
11797
11798 assertTrue(outputLine, matcher.matches());
11799 assertEquals(outputLine, "1", matcher.group(1));
11800 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11801 assertEquals(outputLine, "assign", matcher.group(3));
11802
11803 assertTrue(GrouperClientWs.mostRecentRequest,
11804 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11805 assertTrue(GrouperClientWs.mostRecentRequest,
11806 !GrouperClientWs.mostRecentRequest.contains("actions"));
11807 assertTrue(GrouperClientWs.mostRecentRequest,
11808 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11809 assertTrue(GrouperClientWs.mostRecentRequest,
11810 !GrouperClientWs.mostRecentRequest.contains("params"));
11811 assertTrue(GrouperClientWs.mostRecentRequest,
11812 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
11813
11814
11815
11816
11817 baos = new ByteArrayOutputStream();
11818 System.setOut(new PrintStream(baos));
11819
11820 GrouperClient.main(GrouperClientUtils.splitTrim(
11821 "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex(),
11822 " "));
11823
11824
11825 System.out.flush();
11826 output = new String(baos.toByteArray());
11827
11828 System.setOut(systemOut);
11829
11830 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11831
11832 outputLine = outputLines[0];
11833
11834 matcher = pattern.matcher(outputLines[0]);
11835
11836 assertTrue(outputLine, matcher.matches());
11837 assertEquals(outputLine, "0", matcher.group(1));
11838 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11839 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11840
11841 outputLine = outputLines[1];
11842 matcher = pattern.matcher(outputLines[1]);
11843
11844 assertTrue(outputLine, matcher.matches());
11845 assertEquals(outputLine, "1", matcher.group(1));
11846 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11847 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11848
11849 assertTrue(GrouperClientWs.mostRecentRequest,
11850 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11851 assertTrue(GrouperClientWs.mostRecentRequest,
11852 !GrouperClientWs.mostRecentRequest.contains("actions"));
11853 assertTrue(GrouperClientWs.mostRecentRequest,
11854 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11855 assertTrue(GrouperClientWs.mostRecentRequest,
11856 !GrouperClientWs.mostRecentRequest.contains("params"));
11857 assertTrue(GrouperClientWs.mostRecentRequest,
11858 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
11859
11860
11861
11862
11863 baos = new ByteArrayOutputStream();
11864 System.setOut(new PrintStream(baos));
11865
11866 GrouperClient.main(GrouperClientUtils.splitTrim(
11867 "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex() +" --actions=read", " "));
11868
11869
11870 System.out.flush();
11871 output = new String(baos.toByteArray());
11872
11873 System.setOut(systemOut);
11874
11875 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11876
11877 assertTrue(outputLines.length == 1);
11878
11879 assertTrue(GrouperClientWs.mostRecentRequest,
11880 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11881 assertTrue(GrouperClientWs.mostRecentRequest,
11882 GrouperClientWs.mostRecentRequest.contains("actions"));
11883 assertTrue(GrouperClientWs.mostRecentRequest,
11884 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11885 assertTrue(GrouperClientWs.mostRecentRequest,
11886 !GrouperClientWs.mostRecentRequest.contains("params"));
11887 assertTrue(GrouperClientWs.mostRecentRequest,
11888 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11889
11890
11891
11892
11893 baos = new ByteArrayOutputStream();
11894 System.setOut(new PrintStream(baos));
11895
11896 GrouperClient.main(GrouperClientUtils.splitTrim(
11897 "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex() +" --paramName0=a --paramValue0=b",
11898 " "));
11899
11900
11901 System.out.flush();
11902 output = new String(baos.toByteArray());
11903
11904 System.setOut(systemOut);
11905
11906 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11907
11908 outputLine = outputLines[0];
11909
11910 matcher = pattern.matcher(outputLines[0]);
11911
11912 assertTrue(outputLine, matcher.matches());
11913 assertEquals(outputLine, "0", matcher.group(1));
11914 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11915 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11916
11917 outputLine = outputLines[1];
11918 matcher = pattern.matcher(outputLines[1]);
11919
11920 assertTrue(outputLine, matcher.matches());
11921 assertEquals(outputLine, "1", matcher.group(1));
11922 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11923 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11924
11925 assertTrue(GrouperClientWs.mostRecentRequest,
11926 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11927 assertTrue(GrouperClientWs.mostRecentRequest,
11928 !GrouperClientWs.mostRecentRequest.contains("actions"));
11929 assertTrue(GrouperClientWs.mostRecentRequest,
11930 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11931 assertTrue(GrouperClientWs.mostRecentRequest,
11932 GrouperClientWs.mostRecentRequest.contains("params"));
11933 assertTrue(GrouperClientWs.mostRecentRequest,
11934 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11935
11936
11937
11938
11939 baos = new ByteArrayOutputStream();
11940 System.setOut(new PrintStream(baos));
11941
11942 GrouperClient.main(GrouperClientUtils.splitTrim(
11943 "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex() +" --actAsSubjectId=GrouperSystem", " "));
11944
11945
11946 System.out.flush();
11947 output = new String(baos.toByteArray());
11948
11949 System.setOut(systemOut);
11950
11951 outputLines = GrouperClientUtils.splitTrim(output, "\n");
11952
11953 outputLine = outputLines[0];
11954
11955 matcher = pattern.matcher(outputLines[0]);
11956
11957 assertTrue(outputLine, matcher.matches());
11958 assertEquals(outputLine, "0", matcher.group(1));
11959 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11960 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11961
11962 outputLine = outputLines[1];
11963 matcher = pattern.matcher(outputLines[1]);
11964
11965 assertTrue(outputLine, matcher.matches());
11966 assertEquals(outputLine, "1", matcher.group(1));
11967 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11968 assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11969
11970 assertTrue(GrouperClientWs.mostRecentRequest,
11971 GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11972 assertTrue(GrouperClientWs.mostRecentRequest,
11973 !GrouperClientWs.mostRecentRequest.contains("actions"));
11974 assertTrue(GrouperClientWs.mostRecentRequest,
11975 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11976 assertTrue(GrouperClientWs.mostRecentRequest,
11977 !GrouperClientWs.mostRecentRequest.contains("params"));
11978 assertTrue(GrouperClientWs.mostRecentRequest,
11979 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11980
11981 } finally {
11982 System.setOut(systemOut);
11983 }
11984
11985 }
11986
11987
11988
11989
11990 public void testAssignActionsToAttributeDef() throws Exception {
11991
11992 AttributeDefName nameOfAttributeDef = AttributeDefNameTest.exampleAttributeDefNameDb(
11993 "test", "testAttributeAssignDefName");
11994
11995 final AttributeDef attributeDef = nameOfAttributeDef.getAttributeDef();
11996
11997 PrintStream systemOut = System.out;
11998
11999 ByteArrayOutputStream baos = new ByteArrayOutputStream();
12000 System.setOut(new PrintStream(baos));
12001
12002 try {
12003
12004 GrouperClient
12005 .main(GrouperClientUtils
12006 .splitTrim(
12007 "--operation=assignAttributeDefActionsWs --nameOfAttributeDef=test:testAttributeAssignDefNameDef --actions=read,assign --assign=T",
12008 " "));
12009 System.out.flush();
12010 String output = new String(baos.toByteArray());
12011
12012 System.setOut(systemOut);
12013
12014 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12015
12016 Pattern pattern = Pattern
12017 .compile("^Index (\\d+)\\: nameOfAttributeDef\\: (.+), action: (.+), status: (.+)$");
12018 String outputLine = outputLines[0];
12019
12020 Matcher matcher = pattern.matcher(outputLines[0]);
12021
12022 assertTrue(outputLine, matcher.matches());
12023 assertEquals(outputLine, "0", matcher.group(1));
12024 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12025 assertEquals(outputLine, "read", matcher.group(3));
12026 assertEquals(outputLine, "ADDED", matcher.group(4));
12027
12028 outputLine = outputLines[1];
12029 matcher = pattern.matcher(outputLines[1]);
12030
12031 assertTrue(outputLine, matcher.matches());
12032 assertEquals(outputLine, "1", matcher.group(1));
12033 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12034 assertEquals(outputLine, "assign", matcher.group(3));
12035 assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12036
12037 assertTrue(GrouperClientWs.mostRecentRequest,
12038 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12039 assertTrue(GrouperClientWs.mostRecentRequest,
12040 GrouperClientWs.mostRecentRequest.contains("actions"));
12041 assertTrue(GrouperClientWs.mostRecentRequest,
12042 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12043 assertTrue(GrouperClientWs.mostRecentRequest,
12044 !GrouperClientWs.mostRecentRequest.contains("params"));
12045 assertTrue(GrouperClientWs.mostRecentRequest,
12046 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12047 && GrouperClientWs.mostRecentRequest.contains("<name>"));
12048
12049
12050
12051
12052 baos = new ByteArrayOutputStream();
12053 System.setOut(new PrintStream(baos));
12054
12055 GrouperClient.main(GrouperClientUtils.splitTrim(
12056 "--operation=assignAttributeDefActionsWs --uuidOfAttributeDef="
12057 + attributeDef.getId() + " --actions=read,assign --assign=T",
12058 " "));
12059
12060 System.out.flush();
12061 output = new String(baos.toByteArray());
12062
12063 System.setOut(systemOut);
12064
12065 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12066
12067 outputLine = outputLines[0];
12068
12069 matcher = pattern.matcher(outputLines[0]);
12070
12071 assertTrue(outputLine, matcher.matches());
12072 assertEquals(outputLine, "0", matcher.group(1));
12073 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12074 assertEquals(outputLine, "read", matcher.group(3));
12075 assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12076
12077 outputLine = outputLines[1];
12078 matcher = pattern.matcher(outputLines[1]);
12079
12080 assertTrue(outputLine, matcher.matches());
12081 assertEquals(outputLine, "1", matcher.group(1));
12082 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12083 assertEquals(outputLine, "assign", matcher.group(3));
12084 assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12085
12086 assertTrue(GrouperClientWs.mostRecentRequest,
12087 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12088 assertTrue(GrouperClientWs.mostRecentRequest,
12089 GrouperClientWs.mostRecentRequest.contains("actions"));
12090 assertTrue(GrouperClientWs.mostRecentRequest,
12091 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12092 assertTrue(GrouperClientWs.mostRecentRequest,
12093 !GrouperClientWs.mostRecentRequest.contains("params"));
12094 assertTrue(GrouperClientWs.mostRecentRequest,
12095 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12096 && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
12097
12098
12099
12100
12101 baos = new ByteArrayOutputStream();
12102 System.setOut(new PrintStream(baos));
12103
12104 GrouperClient.main(GrouperClientUtils.splitTrim(
12105 "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12106 + attributeDef.getIdIndex() + " --actions=delete,assign --assign=T",
12107 " "));
12108
12109 System.out.flush();
12110 output = new String(baos.toByteArray());
12111
12112 System.setOut(systemOut);
12113
12114 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12115
12116 outputLine = outputLines[0];
12117
12118 matcher = pattern.matcher(outputLines[0]);
12119
12120 assertTrue(outputLine, matcher.matches());
12121 assertEquals(outputLine, "0", matcher.group(1));
12122 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12123 assertEquals(outputLine, "delete", matcher.group(3));
12124 assertEquals(outputLine, "ADDED", matcher.group(4));
12125
12126 outputLine = outputLines[1];
12127 matcher = pattern.matcher(outputLines[1]);
12128
12129 assertTrue(outputLine, matcher.matches());
12130 assertEquals(outputLine, "1", matcher.group(1));
12131 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12132 assertEquals(outputLine, "assign", matcher.group(3));
12133 assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12134
12135 assertTrue(GrouperClientWs.mostRecentRequest,
12136 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12137 assertTrue(GrouperClientWs.mostRecentRequest,
12138 GrouperClientWs.mostRecentRequest.contains("actions"));
12139 assertTrue(GrouperClientWs.mostRecentRequest,
12140 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12141 assertTrue(GrouperClientWs.mostRecentRequest,
12142 !GrouperClientWs.mostRecentRequest.contains("params"));
12143 assertTrue(GrouperClientWs.mostRecentRequest,
12144 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12145 && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12146
12147
12148
12149
12150 baos = new ByteArrayOutputStream();
12151 System.setOut(new PrintStream(baos));
12152
12153 GrouperClient.main(GrouperClientUtils.splitTrim(
12154 "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12155 + attributeDef.getIdIndex()
12156 + " --actions=view --assign=T --replaceAllExisting=T",
12157 " "));
12158
12159 System.out.flush();
12160 output = new String(baos.toByteArray());
12161
12162 System.setOut(systemOut);
12163
12164 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12165
12166 outputLine = outputLines[0];
12167
12168 matcher = pattern.matcher(outputLines[0]);
12169
12170 List<String> existingActions = new ArrayList<String>();
12171 existingActions.add("read");
12172 existingActions.add("assign");
12173 existingActions.add("delete");
12174
12175 assertTrue(outputLine, matcher.matches());
12176 assertEquals(outputLine, "0", matcher.group(1));
12177 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12178 assertTrue(outputLine, existingActions.contains(matcher.group(3)));
12179 assertEquals(outputLine, "DELETED", matcher.group(4));
12180
12181 outputLine = outputLines[1];
12182 matcher = pattern.matcher(outputLines[1]);
12183
12184 assertTrue(outputLine, matcher.matches());
12185 assertEquals(outputLine, "1", matcher.group(1));
12186 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12187 assertTrue(outputLine, existingActions.contains(matcher.group(3)));
12188 assertEquals(outputLine, "DELETED", matcher.group(4));
12189
12190 outputLine = outputLines[2];
12191 matcher = pattern.matcher(outputLines[2]);
12192
12193 assertTrue(outputLine, matcher.matches());
12194 assertEquals(outputLine, "2", matcher.group(1));
12195 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12196 assertTrue(outputLine, existingActions.contains(matcher.group(3)));
12197 assertEquals(outputLine, "DELETED", matcher.group(4));
12198
12199 outputLine = outputLines[3];
12200 matcher = pattern.matcher(outputLines[3]);
12201
12202 assertTrue(outputLine, matcher.matches());
12203 assertEquals(outputLine, "3", matcher.group(1));
12204 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12205 assertEquals(outputLine, "view", matcher.group(3));
12206 assertEquals(outputLine, "ADDED", matcher.group(4));
12207
12208 assertTrue(GrouperClientWs.mostRecentRequest,
12209 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12210 assertTrue(GrouperClientWs.mostRecentRequest,
12211 GrouperClientWs.mostRecentRequest.contains("actions"));
12212 assertTrue(GrouperClientWs.mostRecentRequest,
12213 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12214 assertTrue(GrouperClientWs.mostRecentRequest,
12215 !GrouperClientWs.mostRecentRequest.contains("params"));
12216 assertTrue(GrouperClientWs.mostRecentRequest,
12217 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12218 && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12219
12220
12221
12222
12223 baos = new ByteArrayOutputStream();
12224 System.setOut(new PrintStream(baos));
12225
12226 GrouperClient.main(GrouperClientUtils.splitTrim(
12227 "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12228 + attributeDef.getIdIndex() + " --actions=view --assign=F",
12229 " "));
12230
12231 System.out.flush();
12232 output = new String(baos.toByteArray());
12233
12234 System.setOut(systemOut);
12235
12236 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12237
12238 outputLine = outputLines[0];
12239
12240 matcher = pattern.matcher(outputLines[0]);
12241
12242 assertTrue(outputLine, matcher.matches());
12243 assertEquals(outputLine, "0", matcher.group(1));
12244 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12245 assertEquals(outputLine, "view", matcher.group(3));
12246 assertEquals(outputLine, "DELETED", matcher.group(4));
12247
12248 assertTrue(GrouperClientWs.mostRecentRequest,
12249 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12250 assertTrue(GrouperClientWs.mostRecentRequest,
12251 GrouperClientWs.mostRecentRequest.contains("actions"));
12252 assertTrue(GrouperClientWs.mostRecentRequest,
12253 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12254 assertTrue(GrouperClientWs.mostRecentRequest,
12255 !GrouperClientWs.mostRecentRequest.contains("params"));
12256 assertTrue(GrouperClientWs.mostRecentRequest,
12257 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12258 && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12259
12260
12261
12262
12263 baos = new ByteArrayOutputStream();
12264 System.setOut(new PrintStream(baos));
12265
12266 GrouperClient.main(GrouperClientUtils.splitTrim(
12267 "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12268 + attributeDef.getIdIndex()
12269 + " --actions=view --assign=T --paramName0=a --paramValue0=b",
12270 " "));
12271
12272 System.out.flush();
12273 output = new String(baos.toByteArray());
12274
12275 System.setOut(systemOut);
12276
12277 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12278
12279 outputLine = outputLines[0];
12280
12281 matcher = pattern.matcher(outputLines[0]);
12282
12283 assertTrue(outputLine, matcher.matches());
12284 assertEquals(outputLine, "0", matcher.group(1));
12285 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12286 assertEquals(outputLine, "view", matcher.group(3));
12287 assertEquals(outputLine, "ADDED", matcher.group(4));
12288
12289 assertTrue(GrouperClientWs.mostRecentRequest,
12290 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12291 assertTrue(GrouperClientWs.mostRecentRequest,
12292 GrouperClientWs.mostRecentRequest.contains("actions"));
12293 assertTrue(GrouperClientWs.mostRecentRequest,
12294 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12295 assertTrue(GrouperClientWs.mostRecentRequest,
12296 GrouperClientWs.mostRecentRequest.contains("params"));
12297 assertTrue(GrouperClientWs.mostRecentRequest,
12298 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12299 && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12300
12301
12302
12303
12304 baos = new ByteArrayOutputStream();
12305 System.setOut(new PrintStream(baos));
12306
12307 GrouperClient.main(GrouperClientUtils.splitTrim(
12308 "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12309 + attributeDef.getIdIndex()
12310 + " --actions=view --assign=T --actAsSubjectId=GrouperSystem",
12311 " "));
12312
12313 System.out.flush();
12314 output = new String(baos.toByteArray());
12315
12316 System.setOut(systemOut);
12317
12318 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12319
12320 outputLine = outputLines[0];
12321
12322 matcher = pattern.matcher(outputLines[0]);
12323
12324 assertTrue(outputLine, matcher.matches());
12325 assertEquals(outputLine, "0", matcher.group(1));
12326 assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12327 assertEquals(outputLine, "view", matcher.group(3));
12328 assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12329
12330 assertTrue(GrouperClientWs.mostRecentRequest,
12331 GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12332 assertTrue(GrouperClientWs.mostRecentRequest,
12333 GrouperClientWs.mostRecentRequest.contains("actions"));
12334 assertTrue(GrouperClientWs.mostRecentRequest,
12335 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12336 assertTrue(GrouperClientWs.mostRecentRequest,
12337 !GrouperClientWs.mostRecentRequest.contains("params"));
12338 assertTrue(GrouperClientWs.mostRecentRequest,
12339 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12340 && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12341
12342 } finally {
12343 System.setOut(systemOut);
12344 }
12345
12346 }
12347
12348
12349
12350
12351 public void testGetAttributeAssignsStem() throws Exception {
12352
12353 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
12354
12355 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
12356
12357 attributeDef.setAssignToGroup(false);
12358 attributeDef.setAssignToStem(true);
12359 attributeDef.store();
12360
12361 Stem stem = new StemSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
12362 .assignStemNameToEdit("test:stemTestAttrAssign").assignName("test:stemTestAttrAssign").assignCreateParentStemsIfNotExist(true)
12363 .assignDescription("description").save();
12364
12365 AttributeAssignResult attributeAssignResult = stem.getAttributeDelegate().assignAttribute(attributeDefName);
12366 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
12367
12368
12369 PrintStream systemOut = System.out;
12370
12371 ByteArrayOutputStream baos = new ByteArrayOutputStream();
12372 System.setOut(new PrintStream(baos));
12373
12374 try {
12375
12376 GrouperClient.main(GrouperClientUtils.splitTrim(
12377 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefNames=test:testAttributeAssignDefNameDef",
12378 " "));
12379 System.out.flush();
12380 String output = new String(baos.toByteArray());
12381
12382 System.setOut(systemOut);
12383
12384 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12385
12386
12387
12388 Pattern pattern = Pattern
12389 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
12390 String outputLine = outputLines[0];
12391
12392 Matcher matcher = pattern.matcher(outputLines[0]);
12393
12394 assertTrue(outputLine, matcher.matches());
12395 assertEquals(outputLine, "0", matcher.group(1));
12396 assertEquals(outputLine, "stem", matcher.group(2));
12397 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
12398 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12399 assertEquals(outputLine, "assign", matcher.group(5));
12400 assertEquals(outputLine, "none", matcher.group(6));
12401 assertEquals(outputLine, "T", matcher.group(7));
12402 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12403
12404 assertTrue(GrouperClientWs.mostRecentRequest,
12405 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12406 assertTrue(GrouperClientWs.mostRecentRequest,
12407 !GrouperClientWs.mostRecentRequest.contains("actions"));
12408 assertTrue(GrouperClientWs.mostRecentRequest,
12409 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12410 assertTrue(GrouperClientWs.mostRecentRequest,
12411 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12412 assertTrue(GrouperClientWs.mostRecentRequest,
12413 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12414 assertTrue(GrouperClientWs.mostRecentRequest,
12415 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12416 assertTrue(GrouperClientWs.mostRecentRequest,
12417 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12418 assertTrue(GrouperClientWs.mostRecentRequest,
12419 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12420 assertTrue(GrouperClientWs.mostRecentRequest,
12421 !GrouperClientWs.mostRecentRequest.contains("params"));
12422 assertTrue(GrouperClientWs.mostRecentRequest,
12423 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12424 assertTrue(GrouperClientWs.mostRecentRequest,
12425 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12426 assertTrue(GrouperClientWs.mostRecentRequest,
12427 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
12428 assertTrue(GrouperClientWs.mostRecentRequest,
12429 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12430 assertTrue(GrouperClientWs.mostRecentRequest,
12431 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12432 assertTrue(GrouperClientWs.mostRecentRequest,
12433 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12434 assertTrue(GrouperClientWs.mostRecentRequest,
12435 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12436 assertTrue(GrouperClientWs.mostRecentRequest,
12437 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12438 assertTrue(GrouperClientWs.mostRecentRequest,
12439 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12440 assertTrue(GrouperClientWs.mostRecentRequest,
12441 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12442
12443
12444
12445
12446 baos = new ByteArrayOutputStream();
12447 System.setOut(new PrintStream(baos));
12448
12449 GrouperClient.main(GrouperClientUtils.splitTrim(
12450 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --ownerStemUuids=" + stem.getUuid(),
12451 " "));
12452
12453
12454 System.out.flush();
12455 output = new String(baos.toByteArray());
12456
12457 System.setOut(systemOut);
12458
12459 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12460
12461 outputLine = outputLines[0];
12462
12463 matcher = pattern.matcher(outputLine);
12464
12465 assertTrue(outputLine, matcher.matches());
12466 assertEquals(outputLine, "0", matcher.group(1));
12467 assertEquals(outputLine, "stem", matcher.group(2));
12468 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
12469 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12470 assertEquals(outputLine, "assign", matcher.group(5));
12471 assertEquals(outputLine, "none", matcher.group(6));
12472 assertEquals(outputLine, "T", matcher.group(7));
12473 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12474
12475 assertTrue(GrouperClientWs.mostRecentRequest,
12476 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12477 assertTrue(GrouperClientWs.mostRecentRequest,
12478 !GrouperClientWs.mostRecentRequest.contains("actions"));
12479 assertTrue(GrouperClientWs.mostRecentRequest,
12480 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12481 assertTrue(GrouperClientWs.mostRecentRequest,
12482 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12483 assertTrue(GrouperClientWs.mostRecentRequest,
12484 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12485 assertTrue(GrouperClientWs.mostRecentRequest,
12486 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12487 assertTrue(GrouperClientWs.mostRecentRequest,
12488 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12489 assertTrue(GrouperClientWs.mostRecentRequest,
12490 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12491 assertTrue(GrouperClientWs.mostRecentRequest,
12492 !GrouperClientWs.mostRecentRequest.contains("params"));
12493 assertTrue(GrouperClientWs.mostRecentRequest,
12494 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12495 assertTrue(GrouperClientWs.mostRecentRequest,
12496 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12497 assertTrue(GrouperClientWs.mostRecentRequest,
12498 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12499 assertTrue(GrouperClientWs.mostRecentRequest,
12500 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12501 assertTrue(GrouperClientWs.mostRecentRequest,
12502 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12503 assertTrue(GrouperClientWs.mostRecentRequest,
12504 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12505 assertTrue(GrouperClientWs.mostRecentRequest,
12506 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12507 assertTrue(GrouperClientWs.mostRecentRequest,
12508 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12509 assertTrue(GrouperClientWs.mostRecentRequest,
12510 GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12511 assertTrue(GrouperClientWs.mostRecentRequest,
12512 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12513
12514
12515
12516
12517
12518 baos = new ByteArrayOutputStream();
12519 System.setOut(new PrintStream(baos));
12520
12521 GrouperClient.main(GrouperClientUtils.splitTrim(
12522 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --ownerStemNames=" + stem.getName(),
12523 " "));
12524
12525
12526 System.out.flush();
12527 output = new String(baos.toByteArray());
12528
12529 System.setOut(systemOut);
12530
12531 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12532
12533 outputLine = outputLines[0];
12534
12535 matcher = pattern.matcher(outputLines[0]);
12536
12537 assertTrue(outputLine, matcher.matches());
12538 assertEquals(outputLine, "0", matcher.group(1));
12539 assertEquals(outputLine, "stem", matcher.group(2));
12540 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
12541 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12542 assertEquals(outputLine, "assign", matcher.group(5));
12543 assertEquals(outputLine, "none", matcher.group(6));
12544 assertEquals(outputLine, "T", matcher.group(7));
12545 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12546
12547 assertTrue(GrouperClientWs.mostRecentRequest,
12548 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12549 assertTrue(GrouperClientWs.mostRecentRequest,
12550 !GrouperClientWs.mostRecentRequest.contains("actions"));
12551 assertTrue(GrouperClientWs.mostRecentRequest,
12552 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12553 assertTrue(GrouperClientWs.mostRecentRequest,
12554 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12555 assertTrue(GrouperClientWs.mostRecentRequest,
12556 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12557 assertTrue(GrouperClientWs.mostRecentRequest,
12558 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12559 assertTrue(GrouperClientWs.mostRecentRequest,
12560 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12561 assertTrue(GrouperClientWs.mostRecentRequest,
12562 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12563 assertTrue(GrouperClientWs.mostRecentRequest,
12564 !GrouperClientWs.mostRecentRequest.contains("params"));
12565 assertTrue(GrouperClientWs.mostRecentRequest,
12566 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12567 assertTrue(GrouperClientWs.mostRecentRequest,
12568 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12569 assertTrue(GrouperClientWs.mostRecentRequest,
12570 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12571 assertTrue(GrouperClientWs.mostRecentRequest,
12572 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12573 assertTrue(GrouperClientWs.mostRecentRequest,
12574 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12575 assertTrue(GrouperClientWs.mostRecentRequest,
12576 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12577 assertTrue(GrouperClientWs.mostRecentRequest,
12578 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12579 assertTrue(GrouperClientWs.mostRecentRequest,
12580 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12581 assertTrue(GrouperClientWs.mostRecentRequest,
12582 GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12583 assertTrue(GrouperClientWs.mostRecentRequest,
12584 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12585
12586
12587
12588
12589 } finally {
12590 System.setOut(systemOut);
12591 }
12592
12593 }
12594
12595
12596
12597
12598 public void testGetAttributeAssignsMember() throws Exception {
12599
12600 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
12601
12602 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
12603
12604 attributeDef.setAssignToGroup(false);
12605 attributeDef.setAssignToMember(true);
12606 attributeDef.store();
12607
12608 GrouperSession grouperSession = GrouperSession.startRootSession();
12609
12610 Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, true);
12611
12612 AttributeAssignResult attributeAssignResult = member.getAttributeDelegate().assignAttribute(attributeDefName);
12613 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
12614
12615
12616 PrintStream systemOut = System.out;
12617
12618 ByteArrayOutputStream baos = new ByteArrayOutputStream();
12619 System.setOut(new PrintStream(baos));
12620
12621 try {
12622
12623 GrouperClient.main(GrouperClientUtils.splitTrim(
12624 "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefNames=test:testAttributeAssignDefNameDef",
12625 " "));
12626 System.out.flush();
12627 String output = new String(baos.toByteArray());
12628
12629 System.setOut(systemOut);
12630
12631 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12632
12633
12634
12635 Pattern pattern = Pattern
12636 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
12637 String outputLine = outputLines[0];
12638
12639 Matcher matcher = pattern.matcher(outputLines[0]);
12640
12641 assertTrue(outputLine, matcher.matches());
12642 assertEquals(outputLine, "0", matcher.group(1));
12643 assertEquals(outputLine, "member", matcher.group(2));
12644 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
12645 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12646 assertEquals(outputLine, "assign", matcher.group(5));
12647 assertEquals(outputLine, "none", matcher.group(6));
12648 assertEquals(outputLine, "T", matcher.group(7));
12649 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12650
12651 assertTrue(GrouperClientWs.mostRecentRequest,
12652 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12653 assertTrue(GrouperClientWs.mostRecentRequest,
12654 !GrouperClientWs.mostRecentRequest.contains("actions"));
12655 assertTrue(GrouperClientWs.mostRecentRequest,
12656 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12657 assertTrue(GrouperClientWs.mostRecentRequest,
12658 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12659 assertTrue(GrouperClientWs.mostRecentRequest,
12660 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12661 assertTrue(GrouperClientWs.mostRecentRequest,
12662 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12663 assertTrue(GrouperClientWs.mostRecentRequest,
12664 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12665 assertTrue(GrouperClientWs.mostRecentRequest,
12666 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12667 assertTrue(GrouperClientWs.mostRecentRequest,
12668 !GrouperClientWs.mostRecentRequest.contains("params"));
12669 assertTrue(GrouperClientWs.mostRecentRequest,
12670 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12671 assertTrue(GrouperClientWs.mostRecentRequest,
12672 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12673 assertTrue(GrouperClientWs.mostRecentRequest,
12674 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
12675 assertTrue(GrouperClientWs.mostRecentRequest,
12676 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12677 assertTrue(GrouperClientWs.mostRecentRequest,
12678 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12679 assertTrue(GrouperClientWs.mostRecentRequest,
12680 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12681 assertTrue(GrouperClientWs.mostRecentRequest,
12682 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12683 assertTrue(GrouperClientWs.mostRecentRequest,
12684 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12685 assertTrue(GrouperClientWs.mostRecentRequest,
12686 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12687 assertTrue(GrouperClientWs.mostRecentRequest,
12688 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12689
12690
12691
12692
12693 baos = new ByteArrayOutputStream();
12694 System.setOut(new PrintStream(baos));
12695
12696 GrouperClient.main(GrouperClientUtils.splitTrim(
12697 "--operation=getAttributeAssignmentsWs --attributeAssignType=member --owner0SubjectId=" + member.getSubjectId(),
12698 " "));
12699
12700
12701 System.out.flush();
12702 output = new String(baos.toByteArray());
12703
12704 System.setOut(systemOut);
12705
12706 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12707
12708 outputLine = outputLines[0];
12709
12710 matcher = pattern.matcher(outputLine);
12711
12712 assertTrue(outputLine, matcher.matches());
12713 assertEquals(outputLine, "0", matcher.group(1));
12714 assertEquals(outputLine, "member", matcher.group(2));
12715 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
12716 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12717 assertEquals(outputLine, "assign", matcher.group(5));
12718 assertEquals(outputLine, "none", matcher.group(6));
12719 assertEquals(outputLine, "T", matcher.group(7));
12720 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12721
12722 assertTrue(GrouperClientWs.mostRecentRequest,
12723 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12724 assertTrue(GrouperClientWs.mostRecentRequest,
12725 !GrouperClientWs.mostRecentRequest.contains("actions"));
12726 assertTrue(GrouperClientWs.mostRecentRequest,
12727 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12728 assertTrue(GrouperClientWs.mostRecentRequest,
12729 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12730 assertTrue(GrouperClientWs.mostRecentRequest,
12731 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12732 assertTrue(GrouperClientWs.mostRecentRequest,
12733 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12734 assertTrue(GrouperClientWs.mostRecentRequest,
12735 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12736 assertTrue(GrouperClientWs.mostRecentRequest,
12737 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12738 assertTrue(GrouperClientWs.mostRecentRequest,
12739 !GrouperClientWs.mostRecentRequest.contains("params"));
12740 assertTrue(GrouperClientWs.mostRecentRequest,
12741 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12742 assertTrue(GrouperClientWs.mostRecentRequest,
12743 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12744 assertTrue(GrouperClientWs.mostRecentRequest,
12745 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12746 assertTrue(GrouperClientWs.mostRecentRequest,
12747 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12748 assertTrue(GrouperClientWs.mostRecentRequest,
12749 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12750 assertTrue(GrouperClientWs.mostRecentRequest,
12751 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12752 assertTrue(GrouperClientWs.mostRecentRequest,
12753 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12754 assertTrue(GrouperClientWs.mostRecentRequest,
12755 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12756 assertTrue(GrouperClientWs.mostRecentRequest,
12757 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12758 assertTrue(GrouperClientWs.mostRecentRequest,
12759 GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12760
12761
12762
12763
12764
12765 baos = new ByteArrayOutputStream();
12766 System.setOut(new PrintStream(baos));
12767
12768 GrouperClient.main(GrouperClientUtils.splitTrim(
12769 "--operation=getAttributeAssignmentsWs --attributeAssignType=member --owner0SubjectIdentifier=id.test.subject.0",
12770 " "));
12771
12772
12773 System.out.flush();
12774 output = new String(baos.toByteArray());
12775
12776 System.setOut(systemOut);
12777
12778 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12779
12780 outputLine = outputLines[0];
12781
12782 matcher = pattern.matcher(outputLines[0]);
12783
12784 assertTrue(outputLine, matcher.matches());
12785 assertEquals(outputLine, "0", matcher.group(1));
12786 assertEquals(outputLine, "member", matcher.group(2));
12787 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
12788 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12789 assertEquals(outputLine, "assign", matcher.group(5));
12790 assertEquals(outputLine, "none", matcher.group(6));
12791 assertEquals(outputLine, "T", matcher.group(7));
12792 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12793
12794 assertTrue(GrouperClientWs.mostRecentRequest,
12795 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12796 assertTrue(GrouperClientWs.mostRecentRequest,
12797 !GrouperClientWs.mostRecentRequest.contains("actions"));
12798 assertTrue(GrouperClientWs.mostRecentRequest,
12799 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12800 assertTrue(GrouperClientWs.mostRecentRequest,
12801 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12802 assertTrue(GrouperClientWs.mostRecentRequest,
12803 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12804 assertTrue(GrouperClientWs.mostRecentRequest,
12805 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12806 assertTrue(GrouperClientWs.mostRecentRequest,
12807 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12808 assertTrue(GrouperClientWs.mostRecentRequest,
12809 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12810 assertTrue(GrouperClientWs.mostRecentRequest,
12811 !GrouperClientWs.mostRecentRequest.contains("params"));
12812 assertTrue(GrouperClientWs.mostRecentRequest,
12813 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12814 assertTrue(GrouperClientWs.mostRecentRequest,
12815 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12816 assertTrue(GrouperClientWs.mostRecentRequest,
12817 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12818 assertTrue(GrouperClientWs.mostRecentRequest,
12819 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12820 assertTrue(GrouperClientWs.mostRecentRequest,
12821 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12822 assertTrue(GrouperClientWs.mostRecentRequest,
12823 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12824 assertTrue(GrouperClientWs.mostRecentRequest,
12825 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12826 assertTrue(GrouperClientWs.mostRecentRequest,
12827 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12828 assertTrue(GrouperClientWs.mostRecentRequest,
12829 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12830 assertTrue(GrouperClientWs.mostRecentRequest,
12831 GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12832
12833
12834
12835
12836 } finally {
12837 System.setOut(systemOut);
12838 }
12839
12840 }
12841
12842
12843
12844
12845 public void testGetAttributeAssignsMembership() throws Exception {
12846
12847 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
12848
12849 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
12850
12851 attributeDef.setAssignToGroup(false);
12852 attributeDef.setAssignToImmMembership(true);
12853 attributeDef.store();
12854
12855 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
12856 .assignGroupNameToEdit("test:membershipTestAttrAssign").assignName("test:membershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
12857 .assignDescription("description").save();
12858
12859 group1.addMember(SubjectTestHelper.SUBJ0);
12860
12861 Membership membership = group1.getMemberships(FieldFinder.find("members", true)).iterator().next();
12862
12863
12864 AttributeAssignResult attributeAssignResult = membership.getAttributeDelegate().assignAttribute(attributeDefName);
12865 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
12866
12867
12868 PrintStream systemOut = System.out;
12869
12870 ByteArrayOutputStream baos = new ByteArrayOutputStream();
12871 System.setOut(new PrintStream(baos));
12872
12873 try {
12874
12875 GrouperClient.main(GrouperClientUtils.splitTrim(
12876 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefNames=test:testAttributeAssignDefNameDef",
12877 " "));
12878 System.out.flush();
12879 String output = new String(baos.toByteArray());
12880
12881 System.setOut(systemOut);
12882
12883 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12884
12885
12886
12887 Pattern pattern = Pattern
12888 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
12889 String outputLine = outputLines[0];
12890
12891 Matcher matcher = pattern.matcher(outputLines[0]);
12892
12893 assertTrue(outputLine, matcher.matches());
12894 assertEquals(outputLine, "0", matcher.group(1));
12895 assertEquals(outputLine, "imm_mem", matcher.group(2));
12896 assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
12897 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12898 assertEquals(outputLine, "assign", matcher.group(5));
12899 assertEquals(outputLine, "none", matcher.group(6));
12900 assertEquals(outputLine, "T", matcher.group(7));
12901 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12902
12903 assertTrue(GrouperClientWs.mostRecentRequest,
12904 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12905 assertTrue(GrouperClientWs.mostRecentRequest,
12906 !GrouperClientWs.mostRecentRequest.contains("actions"));
12907 assertTrue(GrouperClientWs.mostRecentRequest,
12908 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12909 assertTrue(GrouperClientWs.mostRecentRequest,
12910 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12911 assertTrue(GrouperClientWs.mostRecentRequest,
12912 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12913 assertTrue(GrouperClientWs.mostRecentRequest,
12914 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12915 assertTrue(GrouperClientWs.mostRecentRequest,
12916 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12917 assertTrue(GrouperClientWs.mostRecentRequest,
12918 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12919 assertTrue(GrouperClientWs.mostRecentRequest,
12920 !GrouperClientWs.mostRecentRequest.contains("params"));
12921 assertTrue(GrouperClientWs.mostRecentRequest,
12922 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12923 assertTrue(GrouperClientWs.mostRecentRequest,
12924 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12925 assertTrue(GrouperClientWs.mostRecentRequest,
12926 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
12927 assertTrue(GrouperClientWs.mostRecentRequest,
12928 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12929 assertTrue(GrouperClientWs.mostRecentRequest,
12930 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12931 assertTrue(GrouperClientWs.mostRecentRequest,
12932 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12933 assertTrue(GrouperClientWs.mostRecentRequest,
12934 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12935 assertTrue(GrouperClientWs.mostRecentRequest,
12936 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12937 assertTrue(GrouperClientWs.mostRecentRequest,
12938 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12939 assertTrue(GrouperClientWs.mostRecentRequest,
12940 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12941
12942
12943
12944
12945 baos = new ByteArrayOutputStream();
12946 System.setOut(new PrintStream(baos));
12947
12948 GrouperClient.main(GrouperClientUtils.splitTrim(
12949 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --ownerMembershipUuids=" + membership.getUuid(),
12950 " "));
12951
12952
12953 System.out.flush();
12954 output = new String(baos.toByteArray());
12955
12956 System.setOut(systemOut);
12957
12958 outputLines = GrouperClientUtils.splitTrim(output, "\n");
12959
12960 outputLine = outputLines[0];
12961
12962 matcher = pattern.matcher(outputLine);
12963
12964 assertTrue(outputLine, matcher.matches());
12965 assertEquals(outputLine, "0", matcher.group(1));
12966 assertEquals(outputLine, "imm_mem", matcher.group(2));
12967 assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
12968 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12969 assertEquals(outputLine, "assign", matcher.group(5));
12970 assertEquals(outputLine, "none", matcher.group(6));
12971 assertEquals(outputLine, "T", matcher.group(7));
12972 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12973
12974 assertTrue(GrouperClientWs.mostRecentRequest,
12975 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12976 assertTrue(GrouperClientWs.mostRecentRequest,
12977 !GrouperClientWs.mostRecentRequest.contains("actions"));
12978 assertTrue(GrouperClientWs.mostRecentRequest,
12979 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12980 assertTrue(GrouperClientWs.mostRecentRequest,
12981 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12982 assertTrue(GrouperClientWs.mostRecentRequest,
12983 !GrouperClientWs.mostRecentRequest.contains("enabled"));
12984 assertTrue(GrouperClientWs.mostRecentRequest,
12985 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12986 assertTrue(GrouperClientWs.mostRecentRequest,
12987 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12988 assertTrue(GrouperClientWs.mostRecentRequest,
12989 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12990 assertTrue(GrouperClientWs.mostRecentRequest,
12991 !GrouperClientWs.mostRecentRequest.contains("params"));
12992 assertTrue(GrouperClientWs.mostRecentRequest,
12993 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12994 assertTrue(GrouperClientWs.mostRecentRequest,
12995 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12996 assertTrue(GrouperClientWs.mostRecentRequest,
12997 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12998 assertTrue(GrouperClientWs.mostRecentRequest,
12999 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13000 assertTrue(GrouperClientWs.mostRecentRequest,
13001 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13002 assertTrue(GrouperClientWs.mostRecentRequest,
13003 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13004 assertTrue(GrouperClientWs.mostRecentRequest,
13005 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13006 assertTrue(GrouperClientWs.mostRecentRequest,
13007 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13008 assertTrue(GrouperClientWs.mostRecentRequest,
13009 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13010 assertTrue(GrouperClientWs.mostRecentRequest,
13011 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13012
13013
13014
13015 } finally {
13016 System.setOut(systemOut);
13017 }
13018
13019 }
13020
13021
13022
13023
13024 public void testGetAttributeAssignsAnyMembership() throws Exception {
13025
13026 GrouperSession grouperSession = GrouperSession.startRootSession();
13027
13028 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
13029
13030 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
13031
13032 attributeDef.setAssignToGroup(false);
13033 attributeDef.setAssignToEffMembership(true);
13034 attributeDef.store();
13035
13036 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
13037 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
13038 .assignDescription("description").save();
13039
13040 Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
13041 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
13042 .assignDescription("description").save();
13043
13044
13045 group1.addMember(group2.toSubject());
13046 group2.addMember(SubjectTestHelper.SUBJ0);
13047
13048 Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, false);
13049
13050 Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
13051 GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
13052
13053 AttributeAssignResult attributeAssignResult = membership.getAttributeDelegateEffMship().assignAttribute(attributeDefName);
13054 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
13055
13056
13057 PrintStream systemOut = System.out;
13058
13059 ByteArrayOutputStream baos = new ByteArrayOutputStream();
13060 System.setOut(new PrintStream(baos));
13061
13062 try {
13063
13064 GrouperClient.main(GrouperClientUtils.splitTrim(
13065 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefNames=test:testAttributeAssignDefNameDef",
13066 " "));
13067 System.out.flush();
13068 String output = new String(baos.toByteArray());
13069
13070 System.setOut(systemOut);
13071
13072 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
13073
13074
13075
13076 Pattern pattern = Pattern
13077 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
13078 String outputLine = outputLines[0];
13079
13080 Matcher matcher = pattern.matcher(outputLines[0]);
13081
13082 assertTrue(outputLine, matcher.matches());
13083 assertEquals(outputLine, "0", matcher.group(1));
13084 assertEquals(outputLine, "any_mem", matcher.group(2));
13085 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
13086 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13087 assertEquals(outputLine, "assign", matcher.group(5));
13088 assertEquals(outputLine, "none", matcher.group(6));
13089 assertEquals(outputLine, "T", matcher.group(7));
13090 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13091
13092 assertTrue(GrouperClientWs.mostRecentRequest,
13093 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13094 assertTrue(GrouperClientWs.mostRecentRequest,
13095 !GrouperClientWs.mostRecentRequest.contains("actions"));
13096 assertTrue(GrouperClientWs.mostRecentRequest,
13097 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13098 assertTrue(GrouperClientWs.mostRecentRequest,
13099 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13100 assertTrue(GrouperClientWs.mostRecentRequest,
13101 !GrouperClientWs.mostRecentRequest.contains("enabled"));
13102 assertTrue(GrouperClientWs.mostRecentRequest,
13103 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13104 assertTrue(GrouperClientWs.mostRecentRequest,
13105 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13106 assertTrue(GrouperClientWs.mostRecentRequest,
13107 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13108 assertTrue(GrouperClientWs.mostRecentRequest,
13109 !GrouperClientWs.mostRecentRequest.contains("params"));
13110 assertTrue(GrouperClientWs.mostRecentRequest,
13111 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13112 assertTrue(GrouperClientWs.mostRecentRequest,
13113 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13114 assertTrue(GrouperClientWs.mostRecentRequest,
13115 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13116 assertTrue(GrouperClientWs.mostRecentRequest,
13117 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13118 assertTrue(GrouperClientWs.mostRecentRequest,
13119 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13120 assertTrue(GrouperClientWs.mostRecentRequest,
13121 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13122 assertTrue(GrouperClientWs.mostRecentRequest,
13123 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13124 assertTrue(GrouperClientWs.mostRecentRequest,
13125 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13126 assertTrue(GrouperClientWs.mostRecentRequest,
13127 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13128 assertTrue(GrouperClientWs.mostRecentRequest,
13129 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13130
13131
13132
13133
13134 baos = new ByteArrayOutputStream();
13135 System.setOut(new PrintStream(baos));
13136
13137 GrouperClient.main(GrouperClientUtils.splitTrim(
13138 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --ownerMembershipAny0SubjectId=" + member.getSubjectId()
13139 + " --ownerMembershipAny0GroupName=" + group1.getName(),
13140 " "));
13141
13142
13143 System.out.flush();
13144 output = new String(baos.toByteArray());
13145
13146 System.setOut(systemOut);
13147
13148 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13149
13150 outputLine = outputLines[0];
13151
13152 matcher = pattern.matcher(outputLine);
13153
13154 assertTrue(outputLine, matcher.matches());
13155 assertEquals(outputLine, "0", matcher.group(1));
13156 assertEquals(outputLine, "any_mem", matcher.group(2));
13157 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
13158 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13159 assertEquals(outputLine, "assign", matcher.group(5));
13160 assertEquals(outputLine, "none", matcher.group(6));
13161 assertEquals(outputLine, "T", matcher.group(7));
13162 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13163
13164 assertTrue(GrouperClientWs.mostRecentRequest,
13165 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13166 assertTrue(GrouperClientWs.mostRecentRequest,
13167 !GrouperClientWs.mostRecentRequest.contains("actions"));
13168 assertTrue(GrouperClientWs.mostRecentRequest,
13169 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13170 assertTrue(GrouperClientWs.mostRecentRequest,
13171 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13172 assertTrue(GrouperClientWs.mostRecentRequest,
13173 !GrouperClientWs.mostRecentRequest.contains("enabled"));
13174 assertTrue(GrouperClientWs.mostRecentRequest,
13175 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13176 assertTrue(GrouperClientWs.mostRecentRequest,
13177 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13178 assertTrue(GrouperClientWs.mostRecentRequest,
13179 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13180 assertTrue(GrouperClientWs.mostRecentRequest,
13181 !GrouperClientWs.mostRecentRequest.contains("params"));
13182 assertTrue(GrouperClientWs.mostRecentRequest,
13183 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13184 assertTrue(GrouperClientWs.mostRecentRequest,
13185 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13186 assertTrue(GrouperClientWs.mostRecentRequest,
13187 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13188 assertTrue(GrouperClientWs.mostRecentRequest,
13189 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13190 assertTrue(GrouperClientWs.mostRecentRequest,
13191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13192 assertTrue(GrouperClientWs.mostRecentRequest,
13193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13194 assertTrue(GrouperClientWs.mostRecentRequest,
13195 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13196 assertTrue(GrouperClientWs.mostRecentRequest,
13197 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13198 assertTrue(GrouperClientWs.mostRecentRequest,
13199 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13200 assertTrue(GrouperClientWs.mostRecentRequest,
13201 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13202
13203
13204
13205
13206
13207 baos = new ByteArrayOutputStream();
13208 System.setOut(new PrintStream(baos));
13209
13210 GrouperClient.main(GrouperClientUtils.splitTrim(
13211 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --ownerMembershipAny0SubjectId=" + member.getSubjectId()
13212 + " --ownerMembershipAny0GroupIdIndex=" + group1.getIdIndex(),
13213 " "));
13214
13215
13216 System.out.flush();
13217 output = new String(baos.toByteArray());
13218
13219 System.setOut(systemOut);
13220
13221 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13222
13223 outputLine = outputLines[0];
13224
13225 matcher = pattern.matcher(outputLine);
13226
13227 assertTrue(outputLine, matcher.matches());
13228 assertEquals(outputLine, "0", matcher.group(1));
13229 assertEquals(outputLine, "any_mem", matcher.group(2));
13230 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
13231 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13232 assertEquals(outputLine, "assign", matcher.group(5));
13233 assertEquals(outputLine, "none", matcher.group(6));
13234 assertEquals(outputLine, "T", matcher.group(7));
13235 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13236
13237 assertTrue(GrouperClientWs.mostRecentRequest,
13238 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13239 assertTrue(GrouperClientWs.mostRecentRequest,
13240 !GrouperClientWs.mostRecentRequest.contains("actions"));
13241 assertTrue(GrouperClientWs.mostRecentRequest,
13242 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13243 assertTrue(GrouperClientWs.mostRecentRequest,
13244 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13245 assertTrue(GrouperClientWs.mostRecentRequest,
13246 !GrouperClientWs.mostRecentRequest.contains("enabled"));
13247 assertTrue(GrouperClientWs.mostRecentRequest,
13248 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13249 assertTrue(GrouperClientWs.mostRecentRequest,
13250 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13251 assertTrue(GrouperClientWs.mostRecentRequest,
13252 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13253 assertTrue(GrouperClientWs.mostRecentRequest,
13254 !GrouperClientWs.mostRecentRequest.contains("params"));
13255 assertTrue(GrouperClientWs.mostRecentRequest,
13256 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13257 assertTrue(GrouperClientWs.mostRecentRequest,
13258 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13259 assertTrue(GrouperClientWs.mostRecentRequest,
13260 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13261 assertTrue(GrouperClientWs.mostRecentRequest,
13262 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13263 assertTrue(GrouperClientWs.mostRecentRequest,
13264 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13265 assertTrue(GrouperClientWs.mostRecentRequest,
13266 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13267 assertTrue(GrouperClientWs.mostRecentRequest,
13268 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13269 assertTrue(GrouperClientWs.mostRecentRequest,
13270 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13271 assertTrue(GrouperClientWs.mostRecentRequest,
13272 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13273 assertTrue(GrouperClientWs.mostRecentRequest,
13274 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13275
13276
13277
13278 } finally {
13279 System.setOut(systemOut);
13280 }
13281
13282 }
13283
13284
13285
13286
13287 public void testGetAttributeAssignsAttributeDef() throws Exception {
13288
13289 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb(
13290 "test", "testAttributeAssignDefName");
13291
13292 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
13293
13294 attributeDef.setAssignToGroup(false);
13295 attributeDef.setAssignToAttributeDef(true);
13296 attributeDef.store();
13297
13298 AttributeDef attributeDefAssignTo = AttributeDefTest.exampleAttributeDefDb("test",
13299 "testAttributeDefAssignTo");
13300
13301 AttributeAssignResult attributeAssignResult = attributeDefAssignTo
13302 .getAttributeDelegate().assignAttribute(attributeDefName);
13303 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
13304
13305 PrintStream systemOut = System.out;
13306
13307 ByteArrayOutputStream baos = new ByteArrayOutputStream();
13308 System.setOut(new PrintStream(baos));
13309
13310 try {
13311
13312 GrouperClient
13313 .main(GrouperClientUtils
13314 .splitTrim(
13315 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefNames=test:testAttributeAssignDefNameDef",
13316 " "));
13317 System.out.flush();
13318 String output = new String(baos.toByteArray());
13319
13320 System.setOut(systemOut);
13321
13322 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
13323
13324
13325
13326 Pattern pattern = Pattern
13327 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
13328 String outputLine = outputLines[0];
13329
13330 Matcher matcher = pattern.matcher(outputLines[0]);
13331
13332 assertTrue(outputLine, matcher.matches());
13333 assertEquals(outputLine, "0", matcher.group(1));
13334 assertEquals(outputLine, "attr_def", matcher.group(2));
13335 assertEquals(outputLine, "test:testAttributeDefAssignTo", matcher.group(3));
13336 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13337 assertEquals(outputLine, "assign", matcher.group(5));
13338 assertEquals(outputLine, "none", matcher.group(6));
13339 assertEquals(outputLine, "T", matcher.group(7));
13340 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13341
13342 assertTrue(GrouperClientWs.mostRecentRequest,
13343 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13344 assertTrue(GrouperClientWs.mostRecentRequest,
13345 !GrouperClientWs.mostRecentRequest.contains("actions"));
13346 assertTrue(GrouperClientWs.mostRecentRequest,
13347 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13348 assertTrue(GrouperClientWs.mostRecentRequest,
13349 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13350 assertTrue(GrouperClientWs.mostRecentRequest,
13351 !GrouperClientWs.mostRecentRequest.contains("enabled"));
13352 assertTrue(GrouperClientWs.mostRecentRequest,
13353 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13354 assertTrue(GrouperClientWs.mostRecentRequest,
13355 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13356 assertTrue(GrouperClientWs.mostRecentRequest,
13357 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13358 assertTrue(GrouperClientWs.mostRecentRequest,
13359 !GrouperClientWs.mostRecentRequest.contains("params"));
13360 assertTrue(GrouperClientWs.mostRecentRequest,
13361 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13362 assertTrue(GrouperClientWs.mostRecentRequest,
13363 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13364 assertTrue(GrouperClientWs.mostRecentRequest,
13365 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups")
13366 && GrouperClientWs.mostRecentRequest.contains("<name>"));
13367 assertTrue(GrouperClientWs.mostRecentRequest,
13368 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13369 assertTrue(GrouperClientWs.mostRecentRequest,
13370 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13371 assertTrue(GrouperClientWs.mostRecentRequest,
13372 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13373 assertTrue(GrouperClientWs.mostRecentRequest,
13374 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13375 assertTrue(GrouperClientWs.mostRecentRequest,
13376 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13377 assertTrue(GrouperClientWs.mostRecentRequest,
13378 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13379 assertTrue(GrouperClientWs.mostRecentRequest,
13380 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13381
13382
13383
13384
13385 baos = new ByteArrayOutputStream();
13386 System.setOut(new PrintStream(baos));
13387
13388 GrouperClient
13389 .main(GrouperClientUtils
13390 .splitTrim(
13391 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --ownerAttributeDefUuids="
13392 + attributeDefAssignTo.getUuid(),
13393 " "));
13394
13395 System.out.flush();
13396 output = new String(baos.toByteArray());
13397
13398 System.setOut(systemOut);
13399
13400 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13401
13402 outputLine = outputLines[0];
13403
13404 matcher = pattern.matcher(outputLine);
13405
13406 assertTrue(outputLine, matcher.matches());
13407 assertEquals(outputLine, "0", matcher.group(1));
13408 assertEquals(outputLine, "attr_def", matcher.group(2));
13409 assertEquals(outputLine, "test:testAttributeDefAssignTo", matcher.group(3));
13410 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13411 assertEquals(outputLine, "assign", matcher.group(5));
13412 assertEquals(outputLine, "none", matcher.group(6));
13413 assertEquals(outputLine, "T", matcher.group(7));
13414 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13415
13416 assertTrue(GrouperClientWs.mostRecentRequest,
13417 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13418 assertTrue(GrouperClientWs.mostRecentRequest,
13419 !GrouperClientWs.mostRecentRequest.contains("actions"));
13420 assertTrue(GrouperClientWs.mostRecentRequest,
13421 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13422 assertTrue(GrouperClientWs.mostRecentRequest,
13423 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13424 assertTrue(GrouperClientWs.mostRecentRequest,
13425 !GrouperClientWs.mostRecentRequest.contains("enabled"));
13426 assertTrue(GrouperClientWs.mostRecentRequest,
13427 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13428 assertTrue(GrouperClientWs.mostRecentRequest,
13429 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13430 assertTrue(GrouperClientWs.mostRecentRequest,
13431 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13432 assertTrue(GrouperClientWs.mostRecentRequest,
13433 !GrouperClientWs.mostRecentRequest.contains("params"));
13434 assertTrue(GrouperClientWs.mostRecentRequest,
13435 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13436 assertTrue(GrouperClientWs.mostRecentRequest,
13437 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13438 assertTrue(GrouperClientWs.mostRecentRequest,
13439 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13440 assertTrue(GrouperClientWs.mostRecentRequest,
13441 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13442 assertTrue(GrouperClientWs.mostRecentRequest,
13443 GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13444 assertTrue(GrouperClientWs.mostRecentRequest,
13445 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13446 assertTrue(GrouperClientWs.mostRecentRequest,
13447 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13448 assertTrue(GrouperClientWs.mostRecentRequest,
13449 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13450 assertTrue(GrouperClientWs.mostRecentRequest,
13451 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13452 assertTrue(GrouperClientWs.mostRecentRequest,
13453 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13454
13455 } finally {
13456 System.setOut(systemOut);
13457 }
13458
13459 }
13460
13461
13462
13463
13464 public void testAssignAttributesGroup() throws Exception {
13465
13466 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
13467
13468 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
13469
13470 attributeDef.setValueType(AttributeDefValueType.integer);
13471 attributeDef.setMultiValued(true);
13472 attributeDef.store();
13473
13474 Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
13475 .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
13476 .assignDescription("description").save();
13477
13478
13479 group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
13480 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
13481
13482 AttributeAssign attributeAssign = null;
13483
13484
13485
13486 PrintStream systemOut = System.out;
13487
13488 ByteArrayOutputStream baos = new ByteArrayOutputStream();
13489 System.setOut(new PrintStream(baos));
13490
13491 try {
13492
13493 GrouperClient.main(GrouperClientUtils.splitTrim(
13494 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13495 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign",
13496 " "));
13497
13498 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13499
13500 System.out.flush();
13501 String output = new String(baos.toByteArray());
13502
13503 System.setOut(systemOut);
13504
13505 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
13506
13507
13508
13509 Pattern pattern = Pattern
13510 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), " +
13511 "values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
13512 String outputLine = outputLines[0];
13513
13514 Matcher matcher = pattern.matcher(outputLines[0]);
13515
13516 assertTrue(outputLine, matcher.matches());
13517 assertEquals(outputLine, "0", matcher.group(1));
13518 assertEquals(outputLine, "group", matcher.group(2));
13519 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13520 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13521 assertEquals(outputLine, "assign", matcher.group(5));
13522 assertEquals(outputLine, "none", matcher.group(6));
13523 assertEquals(outputLine, "T", matcher.group(7));
13524 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13525 assertEquals(outputLine, "T", matcher.group(9));
13526 assertEquals(outputLine, "F", matcher.group(10));
13527 assertEquals(outputLine, "F", matcher.group(11));
13528
13529 assertTrue(GrouperClientWs.mostRecentRequest,
13530 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13531 assertTrue(GrouperClientWs.mostRecentRequest,
13532 !GrouperClientWs.mostRecentRequest.contains("actions"));
13533 assertTrue(GrouperClientWs.mostRecentRequest,
13534 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13535 assertTrue(GrouperClientWs.mostRecentRequest,
13536 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13537 assertTrue(GrouperClientWs.mostRecentRequest,
13538 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13539 assertTrue(GrouperClientWs.mostRecentRequest,
13540 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13541 assertTrue(GrouperClientWs.mostRecentRequest,
13542 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13543 assertTrue(GrouperClientWs.mostRecentRequest,
13544 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13545 assertTrue(GrouperClientWs.mostRecentRequest,
13546 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13547 assertTrue(GrouperClientWs.mostRecentRequest,
13548 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13549 assertTrue(GrouperClientWs.mostRecentRequest,
13550 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13551 assertTrue(GrouperClientWs.mostRecentRequest,
13552 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13553 assertTrue(GrouperClientWs.mostRecentRequest,
13554 !GrouperClientWs.mostRecentRequest.contains("params"));
13555 assertTrue(GrouperClientWs.mostRecentRequest,
13556 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13557 assertTrue(GrouperClientWs.mostRecentRequest,
13558 !GrouperClientWs.mostRecentRequest.contains("values"));
13559 assertTrue(GrouperClientWs.mostRecentRequest,
13560 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13561 assertTrue(GrouperClientWs.mostRecentRequest,
13562 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13563 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
13564 assertTrue(GrouperClientWs.mostRecentRequest,
13565 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13566 assertTrue(GrouperClientWs.mostRecentRequest,
13567 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13568 assertTrue(GrouperClientWs.mostRecentRequest,
13569 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13570 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
13571 assertTrue(GrouperClientWs.mostRecentRequest,
13572 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13573 assertTrue(GrouperClientWs.mostRecentRequest,
13574 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13575 assertTrue(GrouperClientWs.mostRecentRequest,
13576 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13577 assertTrue(GrouperClientWs.mostRecentRequest,
13578 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13579
13580
13581
13582
13583
13584 baos = new ByteArrayOutputStream();
13585 System.setOut(new PrintStream(baos));
13586
13587 GrouperClient.main(GrouperClientUtils.splitTrim(
13588 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13589 "--attributeDefNameUuids=" + attributeDefName.getId() + " --ownerGroupNames=test:groupTestAttrAssign",
13590 " "));
13591
13592 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13593
13594 System.out.flush();
13595 output = new String(baos.toByteArray());
13596
13597 System.setOut(systemOut);
13598
13599 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13600
13601 outputLine = outputLines[0];
13602
13603 matcher = pattern.matcher(outputLines[0]);
13604
13605 assertTrue(outputLine, matcher.matches());
13606 assertEquals(outputLine, "0", matcher.group(1));
13607 assertEquals(outputLine, "group", matcher.group(2));
13608 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13609 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13610 assertEquals(outputLine, "assign", matcher.group(5));
13611 assertEquals(outputLine, "none", matcher.group(6));
13612 assertEquals(outputLine, "T", matcher.group(7));
13613 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13614 assertEquals(outputLine, "F", matcher.group(9));
13615 assertEquals(outputLine, "F", matcher.group(10));
13616
13617 assertTrue(GrouperClientWs.mostRecentRequest,
13618 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13619 assertTrue(GrouperClientWs.mostRecentRequest,
13620 !GrouperClientWs.mostRecentRequest.contains("actions"));
13621 assertTrue(GrouperClientWs.mostRecentRequest,
13622 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13623 assertTrue(GrouperClientWs.mostRecentRequest,
13624 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13625 assertTrue(GrouperClientWs.mostRecentRequest,
13626 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13627 assertTrue(GrouperClientWs.mostRecentRequest,
13628 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13629 assertTrue(GrouperClientWs.mostRecentRequest,
13630 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13631 assertTrue(GrouperClientWs.mostRecentRequest,
13632 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13633 assertTrue(GrouperClientWs.mostRecentRequest,
13634 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13635 assertTrue(GrouperClientWs.mostRecentRequest,
13636 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13637 assertTrue(GrouperClientWs.mostRecentRequest,
13638 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13639 assertTrue(GrouperClientWs.mostRecentRequest,
13640 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13641 assertTrue(GrouperClientWs.mostRecentRequest,
13642 !GrouperClientWs.mostRecentRequest.contains("params"));
13643 assertTrue(GrouperClientWs.mostRecentRequest,
13644 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13645 assertTrue(GrouperClientWs.mostRecentRequest,
13646 !GrouperClientWs.mostRecentRequest.contains("values"));
13647 assertTrue(GrouperClientWs.mostRecentRequest,
13648 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13649 assertTrue(GrouperClientWs.mostRecentRequest,
13650 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13651 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
13652 assertTrue(GrouperClientWs.mostRecentRequest,
13653 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13654 assertTrue(GrouperClientWs.mostRecentRequest,
13655 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13656 assertTrue(GrouperClientWs.mostRecentRequest,
13657 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13658 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
13659 assertTrue(GrouperClientWs.mostRecentRequest,
13660 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13661 assertTrue(GrouperClientWs.mostRecentRequest,
13662 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13663 assertTrue(GrouperClientWs.mostRecentRequest,
13664 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13665 assertTrue(GrouperClientWs.mostRecentRequest,
13666 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13667
13668
13669
13670
13671 baos = new ByteArrayOutputStream();
13672 System.setOut(new PrintStream(baos));
13673
13674 GrouperClient.main(GrouperClientUtils.splitTrim(
13675 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13676 "--attributeDefNameIdIndexes=" + attributeDefName.getIdIndex() + " --ownerGroupNames=test:groupTestAttrAssign",
13677 " "));
13678
13679 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13680
13681 System.out.flush();
13682 output = new String(baos.toByteArray());
13683
13684 System.setOut(systemOut);
13685
13686 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13687
13688 outputLine = outputLines[0];
13689
13690 matcher = pattern.matcher(outputLines[0]);
13691
13692 assertTrue(outputLine, matcher.matches());
13693 assertEquals(outputLine, "0", matcher.group(1));
13694 assertEquals(outputLine, "group", matcher.group(2));
13695 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13696 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13697 assertEquals(outputLine, "assign", matcher.group(5));
13698 assertEquals(outputLine, "none", matcher.group(6));
13699 assertEquals(outputLine, "T", matcher.group(7));
13700 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13701 assertEquals(outputLine, "F", matcher.group(9));
13702 assertEquals(outputLine, "F", matcher.group(10));
13703
13704 assertTrue(GrouperClientWs.mostRecentRequest,
13705 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13706 assertTrue(GrouperClientWs.mostRecentRequest,
13707 !GrouperClientWs.mostRecentRequest.contains("actions"));
13708 assertTrue(GrouperClientWs.mostRecentRequest,
13709 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13710 assertTrue(GrouperClientWs.mostRecentRequest,
13711 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13712 assertTrue(GrouperClientWs.mostRecentRequest,
13713 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13714 assertTrue(GrouperClientWs.mostRecentRequest,
13715 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13716 assertTrue(GrouperClientWs.mostRecentRequest,
13717 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13718 assertTrue(GrouperClientWs.mostRecentRequest,
13719 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13720 assertTrue(GrouperClientWs.mostRecentRequest,
13721 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13722 assertTrue(GrouperClientWs.mostRecentRequest,
13723 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13724 assertTrue(GrouperClientWs.mostRecentRequest,
13725 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13726 assertTrue(GrouperClientWs.mostRecentRequest,
13727 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13728 assertTrue(GrouperClientWs.mostRecentRequest,
13729 !GrouperClientWs.mostRecentRequest.contains("params"));
13730 assertTrue(GrouperClientWs.mostRecentRequest,
13731 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13732 assertTrue(GrouperClientWs.mostRecentRequest,
13733 !GrouperClientWs.mostRecentRequest.contains("values"));
13734 assertTrue(GrouperClientWs.mostRecentRequest,
13735 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13736 assertTrue(GrouperClientWs.mostRecentRequest,
13737 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13738 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getIdIndex().toString()));
13739 assertTrue(GrouperClientWs.mostRecentRequest,
13740 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13741 assertTrue(GrouperClientWs.mostRecentRequest,
13742 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13743 assertTrue(GrouperClientWs.mostRecentRequest,
13744 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13745 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
13746 assertTrue(GrouperClientWs.mostRecentRequest,
13747 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13748 assertTrue(GrouperClientWs.mostRecentRequest,
13749 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13750 assertTrue(GrouperClientWs.mostRecentRequest,
13751 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13752 assertTrue(GrouperClientWs.mostRecentRequest,
13753 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13754
13755
13756
13757
13758 baos = new ByteArrayOutputStream();
13759 System.setOut(new PrintStream(baos));
13760
13761 GrouperClient.main(GrouperClientUtils.splitTrim(
13762 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13763 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupUuids=" + group.getUuid(),
13764 " "));
13765
13766 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13767
13768 System.out.flush();
13769 output = new String(baos.toByteArray());
13770
13771 System.setOut(systemOut);
13772
13773 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13774
13775 outputLine = outputLines[0];
13776
13777 matcher = pattern.matcher(outputLines[0]);
13778
13779 assertTrue(outputLine, matcher.matches());
13780 assertEquals(outputLine, "0", matcher.group(1));
13781 assertEquals(outputLine, "group", matcher.group(2));
13782 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13783 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13784 assertEquals(outputLine, "assign", matcher.group(5));
13785 assertEquals(outputLine, "none", matcher.group(6));
13786 assertEquals(outputLine, "T", matcher.group(7));
13787 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13788 assertEquals(outputLine, "F", matcher.group(9));
13789 assertEquals(outputLine, "F", matcher.group(10));
13790 assertEquals(outputLine, "F", matcher.group(11));
13791
13792 assertTrue(GrouperClientWs.mostRecentRequest,
13793 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13794 assertTrue(GrouperClientWs.mostRecentRequest,
13795 !GrouperClientWs.mostRecentRequest.contains("actions"));
13796 assertTrue(GrouperClientWs.mostRecentRequest,
13797 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13798 assertTrue(GrouperClientWs.mostRecentRequest,
13799 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13800 assertTrue(GrouperClientWs.mostRecentRequest,
13801 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13802 assertTrue(GrouperClientWs.mostRecentRequest,
13803 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13804 assertTrue(GrouperClientWs.mostRecentRequest,
13805 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13806 assertTrue(GrouperClientWs.mostRecentRequest,
13807 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13808 assertTrue(GrouperClientWs.mostRecentRequest,
13809 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13810 assertTrue(GrouperClientWs.mostRecentRequest,
13811 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13812 assertTrue(GrouperClientWs.mostRecentRequest,
13813 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13814 assertTrue(GrouperClientWs.mostRecentRequest,
13815 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13816 assertTrue(GrouperClientWs.mostRecentRequest,
13817 !GrouperClientWs.mostRecentRequest.contains("params"));
13818 assertTrue(GrouperClientWs.mostRecentRequest,
13819 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13820 assertTrue(GrouperClientWs.mostRecentRequest,
13821 !GrouperClientWs.mostRecentRequest.contains("values"));
13822 assertTrue(GrouperClientWs.mostRecentRequest,
13823 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13824 assertTrue(GrouperClientWs.mostRecentRequest,
13825 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13826 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
13827 assertTrue(GrouperClientWs.mostRecentRequest,
13828 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13829 assertTrue(GrouperClientWs.mostRecentRequest,
13830 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13831 assertTrue(GrouperClientWs.mostRecentRequest,
13832 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13833 && GrouperClientWs.mostRecentRequest.contains(group.getUuid()));
13834 assertTrue(GrouperClientWs.mostRecentRequest,
13835 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13836 assertTrue(GrouperClientWs.mostRecentRequest,
13837 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13838 assertTrue(GrouperClientWs.mostRecentRequest,
13839 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13840 assertTrue(GrouperClientWs.mostRecentRequest,
13841 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13842
13843
13844
13845
13846 baos = new ByteArrayOutputStream();
13847 System.setOut(new PrintStream(baos));
13848
13849 GrouperClient.main(GrouperClientUtils.splitTrim(
13850 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13851 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupIdIndexes=" + group.getIdIndex(),
13852 " "));
13853
13854 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13855
13856 System.out.flush();
13857 output = new String(baos.toByteArray());
13858
13859 System.setOut(systemOut);
13860
13861 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13862
13863 outputLine = outputLines[0];
13864
13865 matcher = pattern.matcher(outputLines[0]);
13866
13867 assertTrue(outputLine, matcher.matches());
13868 assertEquals(outputLine, "0", matcher.group(1));
13869 assertEquals(outputLine, "group", matcher.group(2));
13870 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13871 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13872 assertEquals(outputLine, "assign", matcher.group(5));
13873 assertEquals(outputLine, "none", matcher.group(6));
13874 assertEquals(outputLine, "T", matcher.group(7));
13875 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13876 assertEquals(outputLine, "F", matcher.group(9));
13877 assertEquals(outputLine, "F", matcher.group(10));
13878 assertEquals(outputLine, "F", matcher.group(11));
13879
13880 assertTrue(GrouperClientWs.mostRecentRequest,
13881 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13882 assertTrue(GrouperClientWs.mostRecentRequest,
13883 !GrouperClientWs.mostRecentRequest.contains("actions"));
13884 assertTrue(GrouperClientWs.mostRecentRequest,
13885 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13886 assertTrue(GrouperClientWs.mostRecentRequest,
13887 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13888 assertTrue(GrouperClientWs.mostRecentRequest,
13889 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13890 assertTrue(GrouperClientWs.mostRecentRequest,
13891 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13892 assertTrue(GrouperClientWs.mostRecentRequest,
13893 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13894 assertTrue(GrouperClientWs.mostRecentRequest,
13895 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13896 assertTrue(GrouperClientWs.mostRecentRequest,
13897 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13898 assertTrue(GrouperClientWs.mostRecentRequest,
13899 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13900 assertTrue(GrouperClientWs.mostRecentRequest,
13901 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13902 assertTrue(GrouperClientWs.mostRecentRequest,
13903 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13904 assertTrue(GrouperClientWs.mostRecentRequest,
13905 !GrouperClientWs.mostRecentRequest.contains("params"));
13906 assertTrue(GrouperClientWs.mostRecentRequest,
13907 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13908 assertTrue(GrouperClientWs.mostRecentRequest,
13909 !GrouperClientWs.mostRecentRequest.contains("values"));
13910 assertTrue(GrouperClientWs.mostRecentRequest,
13911 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13912 assertTrue(GrouperClientWs.mostRecentRequest,
13913 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13914 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
13915 assertTrue(GrouperClientWs.mostRecentRequest,
13916 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13917 assertTrue(GrouperClientWs.mostRecentRequest,
13918 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13919 assertTrue(GrouperClientWs.mostRecentRequest,
13920 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13921 && GrouperClientWs.mostRecentRequest.contains(group.getIdIndex().toString()));
13922 assertTrue(GrouperClientWs.mostRecentRequest,
13923 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13924 assertTrue(GrouperClientWs.mostRecentRequest,
13925 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13926 assertTrue(GrouperClientWs.mostRecentRequest,
13927 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13928 assertTrue(GrouperClientWs.mostRecentRequest,
13929 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13930
13931
13932
13933
13934 baos = new ByteArrayOutputStream();
13935 System.setOut(new PrintStream(baos));
13936
13937 GrouperClient.main(GrouperClientUtils.splitTrim(
13938 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13939 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
13940 + " --assignmentEnabledTime=2010/03/05_17:05:13.123",
13941 " "));
13942
13943 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13944
13945 System.out.flush();
13946 output = new String(baos.toByteArray());
13947
13948 System.setOut(systemOut);
13949
13950 outputLines = GrouperClientUtils.splitTrim(output, "\n");
13951
13952 outputLine = outputLines[0];
13953
13954 matcher = pattern.matcher(outputLines[0]);
13955
13956 assertTrue(outputLine, matcher.matches());
13957 assertEquals(outputLine, "0", matcher.group(1));
13958 assertEquals(outputLine, "group", matcher.group(2));
13959 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13960 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13961 assertEquals(outputLine, "assign", matcher.group(5));
13962 assertEquals(outputLine, "none", matcher.group(6));
13963 assertEquals(outputLine, "T", matcher.group(7));
13964 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13965 assertEquals(outputLine, "T", matcher.group(9));
13966 assertEquals(outputLine, "F", matcher.group(10));
13967
13968 assertTrue(GrouperClientWs.mostRecentRequest,
13969 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13970 assertTrue(GrouperClientWs.mostRecentRequest,
13971 !GrouperClientWs.mostRecentRequest.contains("actions"));
13972 assertTrue(GrouperClientWs.mostRecentRequest,
13973 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13974 assertTrue(GrouperClientWs.mostRecentRequest,
13975 GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime")
13976 && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
13977 assertTrue(GrouperClientWs.mostRecentResponse,
13978 GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
13979 assertTrue(GrouperClientWs.mostRecentRequest,
13980 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13981 assertTrue(GrouperClientWs.mostRecentRequest,
13982 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13983 assertTrue(GrouperClientWs.mostRecentRequest,
13984 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13985 assertTrue(GrouperClientWs.mostRecentRequest,
13986 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13987 assertTrue(GrouperClientWs.mostRecentRequest,
13988 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13989 assertTrue(GrouperClientWs.mostRecentRequest,
13990 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13991 assertTrue(GrouperClientWs.mostRecentRequest,
13992 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13993 assertTrue(GrouperClientWs.mostRecentRequest,
13994 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13995 assertTrue(GrouperClientWs.mostRecentRequest,
13996 !GrouperClientWs.mostRecentRequest.contains("params"));
13997 assertTrue(GrouperClientWs.mostRecentRequest,
13998 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13999 assertTrue(GrouperClientWs.mostRecentRequest,
14000 !GrouperClientWs.mostRecentRequest.contains("values"));
14001 assertTrue(GrouperClientWs.mostRecentRequest,
14002 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14003 assertTrue(GrouperClientWs.mostRecentRequest,
14004 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14005 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14006 assertTrue(GrouperClientWs.mostRecentRequest,
14007 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14008 assertTrue(GrouperClientWs.mostRecentRequest,
14009 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14010 assertTrue(GrouperClientWs.mostRecentRequest,
14011 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14012 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14013 assertTrue(GrouperClientWs.mostRecentRequest,
14014 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14015 assertTrue(GrouperClientWs.mostRecentRequest,
14016 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14017 assertTrue(GrouperClientWs.mostRecentRequest,
14018 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14019 assertTrue(GrouperClientWs.mostRecentRequest,
14020 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14021
14022
14023
14024
14025 baos = new ByteArrayOutputStream();
14026 System.setOut(new PrintStream(baos));
14027
14028 GrouperClient.main(GrouperClientUtils.splitTrim(
14029 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14030 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14031 + " --assignmentDisabledTime=2010/03/05_17:05:13.123",
14032 " "));
14033
14034 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14035
14036 System.out.flush();
14037 output = new String(baos.toByteArray());
14038
14039 System.setOut(systemOut);
14040
14041 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14042
14043 outputLine = outputLines[0];
14044
14045 matcher = pattern.matcher(outputLines[0]);
14046
14047 assertTrue(outputLine, matcher.matches());
14048 assertEquals(outputLine, "0", matcher.group(1));
14049 assertEquals(outputLine, "group", matcher.group(2));
14050 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14051 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14052 assertEquals(outputLine, "assign", matcher.group(5));
14053 assertEquals(outputLine, "none", matcher.group(6));
14054 assertEquals(outputLine, "F", matcher.group(7));
14055 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14056 assertEquals(outputLine, "T", matcher.group(9));
14057 assertEquals(outputLine, "F", matcher.group(10));
14058
14059 assertTrue(GrouperClientWs.mostRecentRequest,
14060 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14061 assertTrue(GrouperClientWs.mostRecentRequest,
14062 !GrouperClientWs.mostRecentRequest.contains("actions"));
14063 assertTrue(GrouperClientWs.mostRecentRequest,
14064 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14065 assertTrue(GrouperClientWs.mostRecentRequest,
14066 GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime")
14067 && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
14068 assertTrue(GrouperClientWs.mostRecentResponse,
14069 GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
14070 assertTrue(GrouperClientWs.mostRecentRequest,
14071 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14072 assertTrue(GrouperClientWs.mostRecentRequest,
14073 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14074 assertTrue(GrouperClientWs.mostRecentRequest,
14075 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14076 assertTrue(GrouperClientWs.mostRecentRequest,
14077 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14078 assertTrue(GrouperClientWs.mostRecentRequest,
14079 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14080 assertTrue(GrouperClientWs.mostRecentRequest,
14081 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14082 assertTrue(GrouperClientWs.mostRecentRequest,
14083 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14084 assertTrue(GrouperClientWs.mostRecentRequest,
14085 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14086 assertTrue(GrouperClientWs.mostRecentRequest,
14087 !GrouperClientWs.mostRecentRequest.contains("params"));
14088 assertTrue(GrouperClientWs.mostRecentRequest,
14089 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14090 assertTrue(GrouperClientWs.mostRecentRequest,
14091 !GrouperClientWs.mostRecentRequest.contains("values"));
14092 assertTrue(GrouperClientWs.mostRecentRequest,
14093 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14094 assertTrue(GrouperClientWs.mostRecentRequest,
14095 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14096 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14097 assertTrue(GrouperClientWs.mostRecentRequest,
14098 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14099 assertTrue(GrouperClientWs.mostRecentRequest,
14100 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14101 assertTrue(GrouperClientWs.mostRecentRequest,
14102 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14103 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14104 assertTrue(GrouperClientWs.mostRecentRequest,
14105 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14106 assertTrue(GrouperClientWs.mostRecentRequest,
14107 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14108 assertTrue(GrouperClientWs.mostRecentRequest,
14109 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14110 assertTrue(GrouperClientWs.mostRecentRequest,
14111 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14112
14113
14114
14115
14116 baos = new ByteArrayOutputStream();
14117 System.setOut(new PrintStream(baos));
14118
14119 GrouperClient.main(GrouperClientUtils.splitTrim(
14120 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14121 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14122 + " --assignmentNotes=theNotes",
14123 " "));
14124
14125 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14126
14127 System.out.flush();
14128 output = new String(baos.toByteArray());
14129
14130 System.setOut(systemOut);
14131
14132 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14133
14134 outputLine = outputLines[0];
14135
14136 matcher = pattern.matcher(outputLines[0]);
14137
14138 assertTrue(outputLine, matcher.matches());
14139 assertEquals(outputLine, "0", matcher.group(1));
14140 assertEquals(outputLine, "group", matcher.group(2));
14141 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14142 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14143 assertEquals(outputLine, "assign", matcher.group(5));
14144 assertEquals(outputLine, "none", matcher.group(6));
14145 assertEquals(outputLine, "T", matcher.group(7));
14146 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14147 assertEquals(outputLine, "T", matcher.group(9));
14148 assertEquals(outputLine, "F", matcher.group(10));
14149
14150 assertTrue(GrouperClientWs.mostRecentRequest,
14151 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14152 assertTrue(GrouperClientWs.mostRecentRequest,
14153 !GrouperClientWs.mostRecentRequest.contains("actions"));
14154 assertTrue(GrouperClientWs.mostRecentRequest,
14155 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14156 assertTrue(GrouperClientWs.mostRecentRequest,
14157 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14158 assertTrue(GrouperClientWs.mostRecentResponse,
14159 GrouperClientWs.mostRecentResponse.contains("theNotes"));
14160 assertTrue(GrouperClientWs.mostRecentRequest,
14161 GrouperClientWs.mostRecentRequest.contains("assignmentNotes")
14162 && GrouperClientWs.mostRecentRequest.contains("theNotes") );
14163 assertTrue(GrouperClientWs.mostRecentRequest,
14164 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14165 assertTrue(GrouperClientWs.mostRecentRequest,
14166 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14167 assertTrue(GrouperClientWs.mostRecentRequest,
14168 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14169 assertTrue(GrouperClientWs.mostRecentRequest,
14170 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14171 assertTrue(GrouperClientWs.mostRecentRequest,
14172 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14173 assertTrue(GrouperClientWs.mostRecentRequest,
14174 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14175 assertTrue(GrouperClientWs.mostRecentRequest,
14176 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14177 assertTrue(GrouperClientWs.mostRecentRequest,
14178 !GrouperClientWs.mostRecentRequest.contains("params"));
14179 assertTrue(GrouperClientWs.mostRecentRequest,
14180 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14181 assertTrue(GrouperClientWs.mostRecentRequest,
14182 !GrouperClientWs.mostRecentRequest.contains("values"));
14183 assertTrue(GrouperClientWs.mostRecentRequest,
14184 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14185 assertTrue(GrouperClientWs.mostRecentRequest,
14186 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14187 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14188 assertTrue(GrouperClientWs.mostRecentRequest,
14189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14190 assertTrue(GrouperClientWs.mostRecentRequest,
14191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14192 assertTrue(GrouperClientWs.mostRecentRequest,
14193 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14194 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14195 assertTrue(GrouperClientWs.mostRecentRequest,
14196 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14197 assertTrue(GrouperClientWs.mostRecentRequest,
14198 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14199 assertTrue(GrouperClientWs.mostRecentRequest,
14200 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14201 assertTrue(GrouperClientWs.mostRecentRequest,
14202 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14203
14204
14205
14206
14207
14208 baos = new ByteArrayOutputStream();
14209 System.setOut(new PrintStream(baos));
14210
14211 GrouperClient.main(GrouperClientUtils.splitTrim(
14212 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14213 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14214 + " --delegatable=FALSE",
14215 " "));
14216
14217 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14218
14219 System.out.flush();
14220 output = new String(baos.toByteArray());
14221
14222 System.setOut(systemOut);
14223
14224 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14225
14226 outputLine = outputLines[0];
14227
14228 matcher = pattern.matcher(outputLines[0]);
14229
14230 assertTrue(outputLine, matcher.matches());
14231 assertEquals(outputLine, "0", matcher.group(1));
14232 assertEquals(outputLine, "group", matcher.group(2));
14233 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14234 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14235 assertEquals(outputLine, "assign", matcher.group(5));
14236 assertEquals(outputLine, "none", matcher.group(6));
14237 assertEquals(outputLine, "T", matcher.group(7));
14238 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14239 assertEquals(outputLine, "T", matcher.group(9));
14240 assertEquals(outputLine, "F", matcher.group(10));
14241
14242 assertTrue(GrouperClientWs.mostRecentRequest,
14243 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14244 assertTrue(GrouperClientWs.mostRecentRequest,
14245 !GrouperClientWs.mostRecentRequest.contains("actions"));
14246 assertTrue(GrouperClientWs.mostRecentRequest,
14247 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14248 assertTrue(GrouperClientWs.mostRecentRequest,
14249 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14250
14251
14252 assertTrue(GrouperClientWs.mostRecentRequest,
14253 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14254 assertTrue(GrouperClientWs.mostRecentRequest,
14255 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14256 assertTrue(GrouperClientWs.mostRecentRequest,
14257 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14258 assertTrue(GrouperClientWs.mostRecentRequest,
14259 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14260 assertTrue(GrouperClientWs.mostRecentRequest,
14261 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14262 assertTrue(GrouperClientWs.mostRecentRequest,
14263 GrouperClientWs.mostRecentRequest.contains("delegatable")
14264 && GrouperClientWs.mostRecentRequest.contains("FALSE"));
14265 assertTrue(GrouperClientWs.mostRecentRequest,
14266 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14267 assertTrue(GrouperClientWs.mostRecentRequest,
14268 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14269 assertTrue(GrouperClientWs.mostRecentRequest,
14270 !GrouperClientWs.mostRecentRequest.contains("params"));
14271 assertTrue(GrouperClientWs.mostRecentRequest,
14272 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14273 assertTrue(GrouperClientWs.mostRecentRequest,
14274 !GrouperClientWs.mostRecentRequest.contains("values"));
14275 assertTrue(GrouperClientWs.mostRecentRequest,
14276 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14277 assertTrue(GrouperClientWs.mostRecentRequest,
14278 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14279 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14280 assertTrue(GrouperClientWs.mostRecentRequest,
14281 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14282 assertTrue(GrouperClientWs.mostRecentRequest,
14283 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14284 assertTrue(GrouperClientWs.mostRecentRequest,
14285 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14286 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14287 assertTrue(GrouperClientWs.mostRecentRequest,
14288 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14289 assertTrue(GrouperClientWs.mostRecentRequest,
14290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14291 assertTrue(GrouperClientWs.mostRecentRequest,
14292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14293 assertTrue(GrouperClientWs.mostRecentRequest,
14294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14295
14296
14297
14298
14299 baos = new ByteArrayOutputStream();
14300 System.setOut(new PrintStream(baos));
14301
14302 GrouperClient.main(GrouperClientUtils.splitTrim(
14303 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14304 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14305 + " --actions=assign",
14306 " "));
14307
14308 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14309
14310 System.out.flush();
14311 output = new String(baos.toByteArray());
14312
14313 System.setOut(systemOut);
14314
14315 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14316
14317 outputLine = outputLines[0];
14318
14319 matcher = pattern.matcher(outputLines[0]);
14320
14321 assertTrue(outputLine, matcher.matches());
14322 assertEquals(outputLine, "0", matcher.group(1));
14323 assertEquals(outputLine, "group", matcher.group(2));
14324 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14325 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14326 assertEquals(outputLine, "assign", matcher.group(5));
14327 assertEquals(outputLine, "none", matcher.group(6));
14328 assertEquals(outputLine, "T", matcher.group(7));
14329 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14330 assertEquals(outputLine, "F", matcher.group(9));
14331 assertEquals(outputLine, "F", matcher.group(10));
14332
14333 assertTrue(GrouperClientWs.mostRecentRequest,
14334 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14335 assertTrue(GrouperClientWs.mostRecentRequest,
14336 GrouperClientWs.mostRecentRequest.contains("actions"));
14337 assertTrue(GrouperClientWs.mostRecentRequest,
14338 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14339 assertTrue(GrouperClientWs.mostRecentRequest,
14340 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14341
14342
14343 assertTrue(GrouperClientWs.mostRecentRequest,
14344 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14345 assertTrue(GrouperClientWs.mostRecentRequest,
14346 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14347 assertTrue(GrouperClientWs.mostRecentRequest,
14348 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14349 assertTrue(GrouperClientWs.mostRecentRequest,
14350 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14351 assertTrue(GrouperClientWs.mostRecentRequest,
14352 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14353 assertTrue(GrouperClientWs.mostRecentRequest,
14354 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14355 assertTrue(GrouperClientWs.mostRecentRequest,
14356 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14357 assertTrue(GrouperClientWs.mostRecentRequest,
14358 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14359 assertTrue(GrouperClientWs.mostRecentRequest,
14360 !GrouperClientWs.mostRecentRequest.contains("params"));
14361 assertTrue(GrouperClientWs.mostRecentRequest,
14362 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14363 assertTrue(GrouperClientWs.mostRecentRequest,
14364 !GrouperClientWs.mostRecentRequest.contains("values"));
14365 assertTrue(GrouperClientWs.mostRecentRequest,
14366 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14367 assertTrue(GrouperClientWs.mostRecentRequest,
14368 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14369 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14370 assertTrue(GrouperClientWs.mostRecentRequest,
14371 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14372 assertTrue(GrouperClientWs.mostRecentRequest,
14373 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14374 assertTrue(GrouperClientWs.mostRecentRequest,
14375 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14376 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14377 assertTrue(GrouperClientWs.mostRecentRequest,
14378 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14379 assertTrue(GrouperClientWs.mostRecentRequest,
14380 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14381 assertTrue(GrouperClientWs.mostRecentRequest,
14382 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14383 assertTrue(GrouperClientWs.mostRecentRequest,
14384 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14385
14386
14387
14388
14389 baos = new ByteArrayOutputStream();
14390 System.setOut(new PrintStream(baos));
14391
14392 GrouperClient.main(GrouperClientUtils.splitTrim(
14393 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14394 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14395 + " --values0System=3 --values1System=4 --values2System=5 --attributeAssignValueOperation=replace_values",
14396 " "));
14397
14398 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14399
14400 System.out.flush();
14401 output = new String(baos.toByteArray());
14402
14403 System.setOut(systemOut);
14404
14405 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14406
14407 outputLine = outputLines[0];
14408
14409 matcher = pattern.matcher(outputLines[0]);
14410
14411 assertTrue(outputLine, matcher.matches());
14412 assertEquals(outputLine, "0", matcher.group(1));
14413 assertEquals(outputLine, "group", matcher.group(2));
14414 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14415 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14416 assertEquals(outputLine, "assign", matcher.group(5));
14417 assertEquals(outputLine, "3,4,5", matcher.group(6));
14418 assertEquals(outputLine, "T", matcher.group(7));
14419 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14420 assertEquals(outputLine, "F", matcher.group(9));
14421 assertEquals(outputLine, "F", matcher.group(10));
14422 assertEquals(outputLine, "T", matcher.group(11));
14423
14424 assertTrue(GrouperClientWs.mostRecentRequest,
14425 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14426 assertTrue(GrouperClientWs.mostRecentRequest,
14427 !GrouperClientWs.mostRecentRequest.contains("actions"));
14428 assertTrue(GrouperClientWs.mostRecentRequest,
14429 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14430 assertTrue(GrouperClientWs.mostRecentRequest,
14431 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14432
14433
14434 assertTrue(GrouperClientWs.mostRecentRequest,
14435 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14436 assertTrue(GrouperClientWs.mostRecentRequest,
14437 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14438 assertTrue(GrouperClientWs.mostRecentRequest,
14439 GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14440 assertTrue(GrouperClientWs.mostRecentRequest,
14441 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14442 assertTrue(GrouperClientWs.mostRecentRequest,
14443 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14444 assertTrue(GrouperClientWs.mostRecentRequest,
14445 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14446 assertTrue(GrouperClientWs.mostRecentRequest,
14447 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14448 assertTrue(GrouperClientWs.mostRecentRequest,
14449 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14450 assertTrue(GrouperClientWs.mostRecentRequest,
14451 !GrouperClientWs.mostRecentRequest.contains("params"));
14452 assertTrue(GrouperClientWs.mostRecentRequest,
14453 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14454 assertTrue(GrouperClientWs.mostRecentRequest,
14455 GrouperClientWs.mostRecentRequest.contains("values")
14456 && GrouperClientWs.mostRecentRequest.contains(">3<")
14457 && GrouperClientWs.mostRecentRequest.contains(">4<")
14458 && GrouperClientWs.mostRecentRequest.contains(">5<"));
14459 assertTrue(GrouperClientWs.mostRecentRequest,
14460 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14461 assertTrue(GrouperClientWs.mostRecentRequest,
14462 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14463 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14464 assertTrue(GrouperClientWs.mostRecentRequest,
14465 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14466 assertTrue(GrouperClientWs.mostRecentRequest,
14467 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14468 assertTrue(GrouperClientWs.mostRecentRequest,
14469 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14470 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14471 assertTrue(GrouperClientWs.mostRecentRequest,
14472 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14473 assertTrue(GrouperClientWs.mostRecentRequest,
14474 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14475 assertTrue(GrouperClientWs.mostRecentRequest,
14476 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14477 assertTrue(GrouperClientWs.mostRecentRequest,
14478 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14479
14480
14481
14482
14483 baos = new ByteArrayOutputStream();
14484 System.setOut(new PrintStream(baos));
14485
14486 GrouperClient.main(GrouperClientUtils.splitTrim(
14487 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14488 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14489 + " --includeGroupDetail=T",
14490 " "));
14491
14492 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14493
14494 System.out.flush();
14495 output = new String(baos.toByteArray());
14496
14497 System.setOut(systemOut);
14498
14499 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14500
14501 outputLine = outputLines[0];
14502
14503 matcher = pattern.matcher(outputLines[0]);
14504
14505 assertTrue(outputLine, matcher.matches());
14506 assertEquals(outputLine, "0", matcher.group(1));
14507 assertEquals(outputLine, "group", matcher.group(2));
14508 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14509 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14510 assertEquals(outputLine, "assign", matcher.group(5));
14511 assertEquals(outputLine, "3,4,5", matcher.group(6));
14512 assertEquals(outputLine, "T", matcher.group(7));
14513 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14514 assertEquals(outputLine, "F", matcher.group(9));
14515 assertEquals(outputLine, "F", matcher.group(10));
14516 assertEquals(outputLine, "F", matcher.group(11));
14517
14518 assertTrue(GrouperClientWs.mostRecentRequest,
14519 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14520 assertTrue(GrouperClientWs.mostRecentRequest,
14521 !GrouperClientWs.mostRecentRequest.contains("actions"));
14522 assertTrue(GrouperClientWs.mostRecentRequest,
14523 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14524 assertTrue(GrouperClientWs.mostRecentRequest,
14525 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14526 assertTrue(GrouperClientWs.mostRecentRequest,
14527 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14528 assertTrue(GrouperClientWs.mostRecentRequest,
14529 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14530 assertTrue(GrouperClientWs.mostRecentRequest,
14531 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14532 assertTrue(GrouperClientWs.mostRecentRequest,
14533 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14534 assertTrue(GrouperClientWs.mostRecentRequest,
14535 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14536 assertTrue(GrouperClientWs.mostRecentRequest,
14537 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14538 assertTrue(GrouperClientWs.mostRecentRequest,
14539 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14540 assertTrue(GrouperClientWs.mostRecentRequest,
14541 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14542 assertTrue(GrouperClientWs.mostRecentRequest,
14543 !GrouperClientWs.mostRecentRequest.contains("params"));
14544 assertTrue(GrouperClientWs.mostRecentRequest,
14545 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14546 assertTrue(GrouperClientWs.mostRecentRequest,
14547 !GrouperClientWs.mostRecentRequest.contains("values"));
14548 assertTrue(GrouperClientWs.mostRecentRequest,
14549 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14550 assertTrue(GrouperClientWs.mostRecentRequest,
14551 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14552 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14553 assertTrue(GrouperClientWs.mostRecentRequest,
14554 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14555 assertTrue(GrouperClientWs.mostRecentRequest,
14556 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14557 assertTrue(GrouperClientWs.mostRecentRequest,
14558 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14559 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14560 assertTrue(GrouperClientWs.mostRecentRequest,
14561 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14562 assertTrue(GrouperClientWs.mostRecentRequest,
14563 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14564 assertTrue(GrouperClientWs.mostRecentRequest,
14565 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14566 assertTrue(GrouperClientWs.mostRecentRequest,
14567 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14568
14569
14570
14571
14572
14573 baos = new ByteArrayOutputStream();
14574 System.setOut(new PrintStream(baos));
14575
14576 GrouperClient.main(GrouperClientUtils.splitTrim(
14577 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14578 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14579 + " --includeSubjectDetail=T",
14580 " "));
14581
14582 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14583
14584 System.out.flush();
14585 output = new String(baos.toByteArray());
14586
14587 System.setOut(systemOut);
14588
14589 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14590
14591 outputLine = outputLines[0];
14592
14593 matcher = pattern.matcher(outputLines[0]);
14594
14595 assertTrue(outputLine, matcher.matches());
14596 assertEquals(outputLine, "0", matcher.group(1));
14597 assertEquals(outputLine, "group", matcher.group(2));
14598 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14599 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14600 assertEquals(outputLine, "assign", matcher.group(5));
14601 assertEquals(outputLine, "3,4,5", matcher.group(6));
14602 assertEquals(outputLine, "T", matcher.group(7));
14603 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14604 assertEquals(outputLine, "F", matcher.group(9));
14605 assertEquals(outputLine, "F", matcher.group(10));
14606 assertEquals(outputLine, "F", matcher.group(11));
14607
14608 assertTrue(GrouperClientWs.mostRecentRequest,
14609 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14610 assertTrue(GrouperClientWs.mostRecentRequest,
14611 !GrouperClientWs.mostRecentRequest.contains("actions"));
14612 assertTrue(GrouperClientWs.mostRecentRequest,
14613 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14614 assertTrue(GrouperClientWs.mostRecentRequest,
14615 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14616 assertTrue(GrouperClientWs.mostRecentRequest,
14617 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14618 assertTrue(GrouperClientWs.mostRecentRequest,
14619 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14620 assertTrue(GrouperClientWs.mostRecentRequest,
14621 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14622 assertTrue(GrouperClientWs.mostRecentRequest,
14623 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14624 assertTrue(GrouperClientWs.mostRecentRequest,
14625 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14626 assertTrue(GrouperClientWs.mostRecentRequest,
14627 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14628 assertTrue(GrouperClientWs.mostRecentRequest,
14629 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14630 assertTrue(GrouperClientWs.mostRecentRequest,
14631 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14632 assertTrue(GrouperClientWs.mostRecentRequest,
14633 !GrouperClientWs.mostRecentRequest.contains("params"));
14634 assertTrue(GrouperClientWs.mostRecentRequest,
14635 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14636 assertTrue(GrouperClientWs.mostRecentRequest,
14637 !GrouperClientWs.mostRecentRequest.contains("values"));
14638 assertTrue(GrouperClientWs.mostRecentRequest,
14639 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14640 assertTrue(GrouperClientWs.mostRecentRequest,
14641 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14642 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14643 assertTrue(GrouperClientWs.mostRecentRequest,
14644 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14645 assertTrue(GrouperClientWs.mostRecentRequest,
14646 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14647 assertTrue(GrouperClientWs.mostRecentRequest,
14648 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14649 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14650 assertTrue(GrouperClientWs.mostRecentRequest,
14651 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14652 assertTrue(GrouperClientWs.mostRecentRequest,
14653 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14654 assertTrue(GrouperClientWs.mostRecentRequest,
14655 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14656 assertTrue(GrouperClientWs.mostRecentRequest,
14657 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14658
14659
14660
14661
14662
14663 baos = new ByteArrayOutputStream();
14664 System.setOut(new PrintStream(baos));
14665
14666 GrouperClient.main(GrouperClientUtils.splitTrim(
14667 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14668 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14669 + " --subjectAttributeNames=abc",
14670 " "));
14671
14672 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14673
14674 System.out.flush();
14675 output = new String(baos.toByteArray());
14676
14677 System.setOut(systemOut);
14678
14679 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14680
14681 outputLine = outputLines[0];
14682
14683 matcher = pattern.matcher(outputLines[0]);
14684
14685 assertTrue(outputLine, matcher.matches());
14686 assertEquals(outputLine, "0", matcher.group(1));
14687 assertEquals(outputLine, "group", matcher.group(2));
14688 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14689 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14690 assertEquals(outputLine, "assign", matcher.group(5));
14691 assertEquals(outputLine, "3,4,5", matcher.group(6));
14692 assertEquals(outputLine, "T", matcher.group(7));
14693 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14694 assertEquals(outputLine, "F", matcher.group(9));
14695 assertEquals(outputLine, "F", matcher.group(10));
14696 assertEquals(outputLine, "F", matcher.group(11));
14697
14698 assertTrue(GrouperClientWs.mostRecentRequest,
14699 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14700 assertTrue(GrouperClientWs.mostRecentRequest,
14701 !GrouperClientWs.mostRecentRequest.contains("actions"));
14702 assertTrue(GrouperClientWs.mostRecentRequest,
14703 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14704 assertTrue(GrouperClientWs.mostRecentRequest,
14705 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14706 assertTrue(GrouperClientWs.mostRecentRequest,
14707 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14708 assertTrue(GrouperClientWs.mostRecentRequest,
14709 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14710 assertTrue(GrouperClientWs.mostRecentRequest,
14711 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14712 assertTrue(GrouperClientWs.mostRecentRequest,
14713 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14714 assertTrue(GrouperClientWs.mostRecentRequest,
14715 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14716 assertTrue(GrouperClientWs.mostRecentRequest,
14717 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14718 assertTrue(GrouperClientWs.mostRecentRequest,
14719 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14720 assertTrue(GrouperClientWs.mostRecentRequest,
14721 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14722 assertTrue(GrouperClientWs.mostRecentRequest,
14723 !GrouperClientWs.mostRecentRequest.contains("params"));
14724 assertTrue(GrouperClientWs.mostRecentRequest,
14725 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14726 assertTrue(GrouperClientWs.mostRecentRequest,
14727 !GrouperClientWs.mostRecentRequest.contains("values"));
14728 assertTrue(GrouperClientWs.mostRecentRequest,
14729 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14730 assertTrue(GrouperClientWs.mostRecentRequest,
14731 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14732 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14733 assertTrue(GrouperClientWs.mostRecentRequest,
14734 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14735 assertTrue(GrouperClientWs.mostRecentRequest,
14736 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14737 assertTrue(GrouperClientWs.mostRecentRequest,
14738 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14739 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14740 assertTrue(GrouperClientWs.mostRecentRequest,
14741 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14742 assertTrue(GrouperClientWs.mostRecentRequest,
14743 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14744 assertTrue(GrouperClientWs.mostRecentRequest,
14745 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14746 assertTrue(GrouperClientWs.mostRecentRequest,
14747 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14748
14749
14750
14751
14752
14753 baos = new ByteArrayOutputStream();
14754 System.setOut(new PrintStream(baos));
14755
14756 GrouperClient.main(GrouperClientUtils.splitTrim(
14757 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14758 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14759 + " --paramName0=a --paramValue0=b",
14760 " "));
14761
14762 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14763
14764 System.out.flush();
14765 output = new String(baos.toByteArray());
14766
14767 System.setOut(systemOut);
14768
14769 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14770
14771 outputLine = outputLines[0];
14772
14773 matcher = pattern.matcher(outputLines[0]);
14774
14775 assertTrue(outputLine, matcher.matches());
14776 assertEquals(outputLine, "0", matcher.group(1));
14777 assertEquals(outputLine, "group", matcher.group(2));
14778 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14779 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14780 assertEquals(outputLine, "assign", matcher.group(5));
14781 assertEquals(outputLine, "3,4,5", matcher.group(6));
14782 assertEquals(outputLine, "T", matcher.group(7));
14783 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14784 assertEquals(outputLine, "F", matcher.group(9));
14785 assertEquals(outputLine, "F", matcher.group(10));
14786 assertEquals(outputLine, "F", matcher.group(11));
14787
14788 assertTrue(GrouperClientWs.mostRecentRequest,
14789 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14790 assertTrue(GrouperClientWs.mostRecentRequest,
14791 !GrouperClientWs.mostRecentRequest.contains("actions"));
14792 assertTrue(GrouperClientWs.mostRecentRequest,
14793 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14794 assertTrue(GrouperClientWs.mostRecentRequest,
14795 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14796 assertTrue(GrouperClientWs.mostRecentRequest,
14797 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14798 assertTrue(GrouperClientWs.mostRecentRequest,
14799 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14800 assertTrue(GrouperClientWs.mostRecentRequest,
14801 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14802 assertTrue(GrouperClientWs.mostRecentRequest,
14803 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14804 assertTrue(GrouperClientWs.mostRecentRequest,
14805 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14806 assertTrue(GrouperClientWs.mostRecentRequest,
14807 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14808 assertTrue(GrouperClientWs.mostRecentRequest,
14809 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14810 assertTrue(GrouperClientWs.mostRecentRequest,
14811 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14812 assertTrue(GrouperClientWs.mostRecentRequest,
14813 GrouperClientWs.mostRecentRequest.contains("params"));
14814 assertTrue(GrouperClientWs.mostRecentRequest,
14815 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14816 assertTrue(GrouperClientWs.mostRecentRequest,
14817 !GrouperClientWs.mostRecentRequest.contains("values"));
14818 assertTrue(GrouperClientWs.mostRecentRequest,
14819 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14820 assertTrue(GrouperClientWs.mostRecentRequest,
14821 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14822 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14823 assertTrue(GrouperClientWs.mostRecentRequest,
14824 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14825 assertTrue(GrouperClientWs.mostRecentRequest,
14826 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14827 assertTrue(GrouperClientWs.mostRecentRequest,
14828 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14829 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14830 assertTrue(GrouperClientWs.mostRecentRequest,
14831 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14832 assertTrue(GrouperClientWs.mostRecentRequest,
14833 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14834 assertTrue(GrouperClientWs.mostRecentRequest,
14835 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14836 assertTrue(GrouperClientWs.mostRecentRequest,
14837 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14838
14839
14840
14841
14842
14843 baos = new ByteArrayOutputStream();
14844 System.setOut(new PrintStream(baos));
14845
14846 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14847
14848 String attributeAssignId = attributeAssign.getId();
14849
14850 GrouperClient.main(GrouperClientUtils.splitTrim(
14851 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=remove_attr "
14852 + " --attributeAssignUuids=" + attributeAssign.getId(),
14853 " "));
14854
14855 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
14856
14857 assertNull("Should be deleted", attributeAssign);
14858
14859 System.out.flush();
14860 output = new String(baos.toByteArray());
14861
14862 System.setOut(systemOut);
14863
14864 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14865
14866 outputLine = outputLines[0];
14867
14868 matcher = pattern.matcher(outputLines[0]);
14869
14870 assertTrue(outputLine, matcher.matches());
14871 assertEquals(outputLine, "0", matcher.group(1));
14872 assertEquals(outputLine, "group", matcher.group(2));
14873 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14874 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14875 assertEquals(outputLine, "assign", matcher.group(5));
14876 assertEquals(outputLine, "none", matcher.group(6));
14877 assertEquals(outputLine, "T", matcher.group(7));
14878 assertEquals(outputLine, attributeAssignId, matcher.group(8));
14879 assertEquals(outputLine, "T", matcher.group(9));
14880 assertEquals(outputLine, "T", matcher.group(10));
14881 assertEquals(outputLine, "F", matcher.group(11));
14882
14883 assertTrue(GrouperClientWs.mostRecentRequest,
14884 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14885 assertTrue(GrouperClientWs.mostRecentRequest,
14886 !GrouperClientWs.mostRecentRequest.contains("actions"));
14887 assertTrue(GrouperClientWs.mostRecentRequest,
14888 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14889 assertTrue(GrouperClientWs.mostRecentRequest,
14890 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14891 assertTrue(GrouperClientWs.mostRecentRequest,
14892 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14893 assertTrue(GrouperClientWs.mostRecentRequest,
14894 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14895 assertTrue(GrouperClientWs.mostRecentRequest,
14896 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14897 assertTrue(GrouperClientWs.mostRecentRequest,
14898 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14899 assertTrue(GrouperClientWs.mostRecentRequest,
14900 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14901 assertTrue(GrouperClientWs.mostRecentRequest,
14902 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14903 assertTrue(GrouperClientWs.mostRecentRequest,
14904 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14905 assertTrue(GrouperClientWs.mostRecentRequest,
14906 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14907 assertTrue(GrouperClientWs.mostRecentRequest,
14908 !GrouperClientWs.mostRecentRequest.contains("params"));
14909 assertTrue(GrouperClientWs.mostRecentRequest,
14910 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14911 assertTrue(GrouperClientWs.mostRecentRequest,
14912 !GrouperClientWs.mostRecentRequest.contains("values"));
14913 assertTrue(GrouperClientWs.mostRecentRequest,
14914 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14915 assertTrue(GrouperClientWs.mostRecentRequest,
14916 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14917 && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14918 assertTrue(GrouperClientWs.mostRecentRequest,
14919 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14920 assertTrue(GrouperClientWs.mostRecentRequest,
14921 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14922 assertTrue(GrouperClientWs.mostRecentRequest,
14923 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14924 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14925 assertTrue(GrouperClientWs.mostRecentRequest,
14926 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14927 assertTrue(GrouperClientWs.mostRecentRequest,
14928 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14929 assertTrue(GrouperClientWs.mostRecentRequest,
14930 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14931 assertTrue(GrouperClientWs.mostRecentRequest,
14932 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14933
14934
14935
14936
14937 baos = new ByteArrayOutputStream();
14938 System.setOut(new PrintStream(baos));
14939
14940 attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
14941
14942 attributeAssignId = attributeAssign.getId();
14943
14944 GrouperClient.main(GrouperClientUtils.splitTrim(
14945 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=remove_attr "
14946 + " --attributeAssignUuids=" + attributeAssign.getId() + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
14947 " "));
14948
14949 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
14950
14951 assertNull("Should be deleted", attributeAssign);
14952
14953 System.out.flush();
14954 output = new String(baos.toByteArray());
14955
14956 System.setOut(systemOut);
14957
14958 outputLines = GrouperClientUtils.splitTrim(output, "\n");
14959
14960 outputLine = GrouperClientUtils.trim(outputLines[0]);
14961
14962 assertEquals(outputLine, "group", outputLine);
14963
14964 assertTrue(GrouperClientWs.mostRecentRequest,
14965 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14966 assertTrue(GrouperClientWs.mostRecentRequest,
14967 !GrouperClientWs.mostRecentRequest.contains("actions"));
14968 assertTrue(GrouperClientWs.mostRecentRequest,
14969 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14970 assertTrue(GrouperClientWs.mostRecentRequest,
14971 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14972 assertTrue(GrouperClientWs.mostRecentRequest,
14973 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14974 assertTrue(GrouperClientWs.mostRecentRequest,
14975 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14976 assertTrue(GrouperClientWs.mostRecentRequest,
14977 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14978 assertTrue(GrouperClientWs.mostRecentRequest,
14979 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14980 assertTrue(GrouperClientWs.mostRecentRequest,
14981 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14982 assertTrue(GrouperClientWs.mostRecentRequest,
14983 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14984 assertTrue(GrouperClientWs.mostRecentRequest,
14985 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14986 assertTrue(GrouperClientWs.mostRecentRequest,
14987 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14988 assertTrue(GrouperClientWs.mostRecentRequest,
14989 !GrouperClientWs.mostRecentRequest.contains("params"));
14990 assertTrue(GrouperClientWs.mostRecentRequest,
14991 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14992 assertTrue(GrouperClientWs.mostRecentRequest,
14993 !GrouperClientWs.mostRecentRequest.contains("values"));
14994 assertTrue(GrouperClientWs.mostRecentRequest,
14995 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14996 assertTrue(GrouperClientWs.mostRecentRequest,
14997 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14998 && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14999 assertTrue(GrouperClientWs.mostRecentRequest,
15000 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15001 assertTrue(GrouperClientWs.mostRecentRequest,
15002 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15003 assertTrue(GrouperClientWs.mostRecentRequest,
15004 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
15005 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
15006 assertTrue(GrouperClientWs.mostRecentRequest,
15007 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15008 assertTrue(GrouperClientWs.mostRecentRequest,
15009 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15010 assertTrue(GrouperClientWs.mostRecentRequest,
15011 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15012 assertTrue(GrouperClientWs.mostRecentRequest,
15013 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15014
15015
15016
15017
15018
15019 baos = new ByteArrayOutputStream();
15020 System.setOut(new PrintStream(baos));
15021
15022 attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
15023
15024 attributeAssignId = attributeAssign.getId();
15025
15026 GrouperClient.main(GrouperClientUtils.splitTrim(
15027 "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=remove_attr "
15028 + " --attributeAssignUuids=" + attributeAssign.getId() + " --actAsSubjectId=GrouperSystem",
15029 " "));
15030
15031 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
15032
15033 assertNull("Should be deleted", attributeAssign);
15034
15035 System.out.flush();
15036 output = new String(baos.toByteArray());
15037
15038 System.setOut(systemOut);
15039
15040 outputLines = GrouperClientUtils.splitTrim(output, "\n");
15041
15042 outputLine = outputLines[0];
15043
15044 matcher = pattern.matcher(outputLines[0]);
15045
15046 assertTrue(outputLine, matcher.matches());
15047 assertEquals(outputLine, "0", matcher.group(1));
15048 assertEquals(outputLine, "group", matcher.group(2));
15049 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
15050 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15051 assertEquals(outputLine, "assign", matcher.group(5));
15052 assertEquals(outputLine, "none", matcher.group(6));
15053 assertEquals(outputLine, "T", matcher.group(7));
15054 assertEquals(outputLine, attributeAssignId, matcher.group(8));
15055 assertEquals(outputLine, "T", matcher.group(9));
15056 assertEquals(outputLine, "T", matcher.group(10));
15057 assertEquals(outputLine, "F", matcher.group(11));
15058
15059 assertTrue(GrouperClientWs.mostRecentRequest,
15060 GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15061 assertTrue(GrouperClientWs.mostRecentRequest,
15062 !GrouperClientWs.mostRecentRequest.contains("actions"));
15063 assertTrue(GrouperClientWs.mostRecentRequest,
15064 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15065 assertTrue(GrouperClientWs.mostRecentRequest,
15066 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15067 assertTrue(GrouperClientWs.mostRecentRequest,
15068 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15069 assertTrue(GrouperClientWs.mostRecentRequest,
15070 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15071 assertTrue(GrouperClientWs.mostRecentRequest,
15072 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15073 assertTrue(GrouperClientWs.mostRecentRequest,
15074 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15075 assertTrue(GrouperClientWs.mostRecentRequest,
15076 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15077 assertTrue(GrouperClientWs.mostRecentRequest,
15078 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15079 assertTrue(GrouperClientWs.mostRecentRequest,
15080 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15081 assertTrue(GrouperClientWs.mostRecentRequest,
15082 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15083 assertTrue(GrouperClientWs.mostRecentRequest,
15084 !GrouperClientWs.mostRecentRequest.contains("params"));
15085 assertTrue(GrouperClientWs.mostRecentRequest,
15086 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15087 assertTrue(GrouperClientWs.mostRecentRequest,
15088 !GrouperClientWs.mostRecentRequest.contains("values"));
15089 assertTrue(GrouperClientWs.mostRecentRequest,
15090 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15091 assertTrue(GrouperClientWs.mostRecentRequest,
15092 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15093 && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15094 assertTrue(GrouperClientWs.mostRecentRequest,
15095 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15096 assertTrue(GrouperClientWs.mostRecentRequest,
15097 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15098 assertTrue(GrouperClientWs.mostRecentRequest,
15099 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
15100 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
15101 assertTrue(GrouperClientWs.mostRecentRequest,
15102 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15103 assertTrue(GrouperClientWs.mostRecentRequest,
15104 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15105 assertTrue(GrouperClientWs.mostRecentRequest,
15106 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15107 assertTrue(GrouperClientWs.mostRecentRequest,
15108 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15109
15110
15111
15112 } finally {
15113 System.setOut(systemOut);
15114 }
15115
15116 }
15117
15118
15119
15120
15121 public void testAssignAttributesStem() throws Exception {
15122
15123 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15124
15125 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15126
15127 attributeDef.setAssignToGroup(false);
15128 attributeDef.setAssignToStem(true);
15129 attributeDef.store();
15130
15131 Stem stem = new StemSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15132 .assignStemNameToEdit("test:stemTestAttrAssign").assignName("test:stemTestAttrAssign").assignCreateParentStemsIfNotExist(true)
15133 .assignDescription("description").save();
15134
15135
15136 AttributeAssign attributeAssign = null;
15137
15138
15139
15140 PrintStream systemOut = System.out;
15141
15142 ByteArrayOutputStream baos = new ByteArrayOutputStream();
15143 System.setOut(new PrintStream(baos));
15144
15145 try {
15146
15147 GrouperClient.main(GrouperClientUtils.splitTrim(
15148 "--operation=assignAttributesWs --attributeAssignType=stem --attributeAssignOperation=assign_attr " +
15149 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerStemNames=test:stemTestAttrAssign",
15150 " "));
15151
15152 attributeAssign = stem.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15153
15154 System.out.flush();
15155 String output = new String(baos.toByteArray());
15156
15157 System.setOut(systemOut);
15158
15159 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15160
15161
15162
15163 Pattern pattern = Pattern
15164 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15165 String outputLine = outputLines[0];
15166
15167 Matcher matcher = pattern.matcher(outputLines[0]);
15168
15169 assertTrue(outputLine, matcher.matches());
15170 assertEquals(outputLine, "0", matcher.group(1));
15171 assertEquals(outputLine, "stem", matcher.group(2));
15172 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
15173 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15174 assertEquals(outputLine, "assign", matcher.group(5));
15175 assertEquals(outputLine, "none", matcher.group(6));
15176 assertEquals(outputLine, "T", matcher.group(7));
15177 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15178 assertEquals(outputLine, "T", matcher.group(9));
15179 assertEquals(outputLine, "F", matcher.group(10));
15180
15181 assertTrue(GrouperClientWs.mostRecentRequest,
15182 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15183 assertTrue(GrouperClientWs.mostRecentRequest,
15184 !GrouperClientWs.mostRecentRequest.contains("actions"));
15185 assertTrue(GrouperClientWs.mostRecentRequest,
15186 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15187 assertTrue(GrouperClientWs.mostRecentRequest,
15188 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15189 assertTrue(GrouperClientWs.mostRecentRequest,
15190 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15191 assertTrue(GrouperClientWs.mostRecentRequest,
15192 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15193 assertTrue(GrouperClientWs.mostRecentRequest,
15194 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15195 assertTrue(GrouperClientWs.mostRecentRequest,
15196 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15197 assertTrue(GrouperClientWs.mostRecentRequest,
15198 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15199 assertTrue(GrouperClientWs.mostRecentRequest,
15200 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15201 assertTrue(GrouperClientWs.mostRecentRequest,
15202 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15203 assertTrue(GrouperClientWs.mostRecentRequest,
15204 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15205 assertTrue(GrouperClientWs.mostRecentRequest,
15206 !GrouperClientWs.mostRecentRequest.contains("params"));
15207 assertTrue(GrouperClientWs.mostRecentRequest,
15208 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15209 assertTrue(GrouperClientWs.mostRecentRequest,
15210 !GrouperClientWs.mostRecentRequest.contains("values"));
15211 assertTrue(GrouperClientWs.mostRecentRequest,
15212 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15213 assertTrue(GrouperClientWs.mostRecentRequest,
15214 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15215 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15216 assertTrue(GrouperClientWs.mostRecentRequest,
15217 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15218 assertTrue(GrouperClientWs.mostRecentRequest,
15219 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15220 assertTrue(GrouperClientWs.mostRecentRequest,
15221 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15222 assertTrue(GrouperClientWs.mostRecentRequest,
15223 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15224 assertTrue(GrouperClientWs.mostRecentRequest,
15225 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15226 assertTrue(GrouperClientWs.mostRecentRequest,
15227 GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups")
15228 && GrouperClientWs.mostRecentRequest.contains("test:stemTestAttrAssign"));
15229 assertTrue(GrouperClientWs.mostRecentRequest,
15230 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15231
15232
15233 baos = new ByteArrayOutputStream();
15234 System.setOut(new PrintStream(baos));
15235
15236 GrouperClient.main(GrouperClientUtils.splitTrim(
15237 "--operation=assignAttributesWs --attributeAssignType=stem --attributeAssignOperation=assign_attr " +
15238 "--attributeDefNameUuids=" + attributeDefName.getId() + " --ownerStemUuids=" + stem.getUuid(),
15239 " "));
15240
15241 attributeAssign = stem.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15242
15243 System.out.flush();
15244 output = new String(baos.toByteArray());
15245
15246 System.setOut(systemOut);
15247
15248 outputLines = GrouperClientUtils.splitTrim(output, "\n");
15249
15250 outputLine = outputLines[0];
15251
15252 matcher = pattern.matcher(outputLines[0]);
15253
15254 assertTrue(outputLine, matcher.matches());
15255 assertEquals(outputLine, "0", matcher.group(1));
15256 assertEquals(outputLine, "stem", matcher.group(2));
15257 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
15258 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15259 assertEquals(outputLine, "assign", matcher.group(5));
15260 assertEquals(outputLine, "none", matcher.group(6));
15261 assertEquals(outputLine, "T", matcher.group(7));
15262 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15263 assertEquals(outputLine, "F", matcher.group(9));
15264 assertEquals(outputLine, "F", matcher.group(10));
15265
15266 assertTrue(GrouperClientWs.mostRecentRequest,
15267 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15268 assertTrue(GrouperClientWs.mostRecentRequest,
15269 !GrouperClientWs.mostRecentRequest.contains("actions"));
15270 assertTrue(GrouperClientWs.mostRecentRequest,
15271 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15272 assertTrue(GrouperClientWs.mostRecentRequest,
15273 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15274 assertTrue(GrouperClientWs.mostRecentRequest,
15275 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15276 assertTrue(GrouperClientWs.mostRecentRequest,
15277 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15278 assertTrue(GrouperClientWs.mostRecentRequest,
15279 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15280 assertTrue(GrouperClientWs.mostRecentRequest,
15281 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15282 assertTrue(GrouperClientWs.mostRecentRequest,
15283 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15284 assertTrue(GrouperClientWs.mostRecentRequest,
15285 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15286 assertTrue(GrouperClientWs.mostRecentRequest,
15287 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15288 assertTrue(GrouperClientWs.mostRecentRequest,
15289 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15290 assertTrue(GrouperClientWs.mostRecentRequest,
15291 !GrouperClientWs.mostRecentRequest.contains("params"));
15292 assertTrue(GrouperClientWs.mostRecentRequest,
15293 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15294 assertTrue(GrouperClientWs.mostRecentRequest,
15295 !GrouperClientWs.mostRecentRequest.contains("values"));
15296 assertTrue(GrouperClientWs.mostRecentRequest,
15297 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15298 assertTrue(GrouperClientWs.mostRecentRequest,
15299 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15300 && GrouperClientWs.mostRecentRequest.contains(stem.getUuid()));
15301 assertTrue(GrouperClientWs.mostRecentRequest,
15302 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15303 assertTrue(GrouperClientWs.mostRecentRequest,
15304 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15305 assertTrue(GrouperClientWs.mostRecentRequest,
15306 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15307 assertTrue(GrouperClientWs.mostRecentRequest,
15308 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15309 assertTrue(GrouperClientWs.mostRecentRequest,
15310 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15311 assertTrue(GrouperClientWs.mostRecentRequest,
15312 GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups")
15313 && GrouperClientWs.mostRecentRequest.contains(stem.getUuid()));
15314 assertTrue(GrouperClientWs.mostRecentRequest,
15315 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15316
15317
15318 } finally {
15319 System.setOut(systemOut);
15320 }
15321
15322 }
15323
15324
15325
15326
15327 public void testAssignAttributesMember() throws Exception {
15328
15329 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15330
15331 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15332
15333 attributeDef.setAssignToGroup(false);
15334 attributeDef.setAssignToMember(true);
15335 attributeDef.store();
15336
15337 GrouperSession grouperSession = GrouperSession.startRootSession();
15338
15339 Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, true);
15340
15341
15342 AttributeAssign attributeAssign = null;
15343
15344
15345
15346 PrintStream systemOut = System.out;
15347
15348 ByteArrayOutputStream baos = new ByteArrayOutputStream();
15349 System.setOut(new PrintStream(baos));
15350
15351 try {
15352
15353 GrouperClient.main(GrouperClientUtils.splitTrim(
15354 "--operation=assignAttributesWs --attributeAssignType=member --attributeAssignOperation=assign_attr " +
15355 "--attributeDefNameNames=test:testAttributeAssignDefName --owner0SubjectId=" + SubjectTestHelper.SUBJ0_ID,
15356 " "));
15357
15358 attributeAssign = member.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15359
15360 System.out.flush();
15361 String output = new String(baos.toByteArray());
15362
15363 System.setOut(systemOut);
15364
15365 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15366
15367
15368
15369 Pattern pattern = Pattern
15370 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15371 String outputLine = outputLines[0];
15372
15373 Matcher matcher = pattern.matcher(outputLines[0]);
15374
15375 assertTrue(outputLine, matcher.matches());
15376 assertEquals(outputLine, "0", matcher.group(1));
15377 assertEquals(outputLine, "member", matcher.group(2));
15378 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
15379 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15380 assertEquals(outputLine, "assign", matcher.group(5));
15381 assertEquals(outputLine, "none", matcher.group(6));
15382 assertEquals(outputLine, "T", matcher.group(7));
15383 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15384 assertEquals(outputLine, "T", matcher.group(9));
15385 assertEquals(outputLine, "F", matcher.group(10));
15386
15387 assertTrue(GrouperClientWs.mostRecentRequest,
15388 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15389 assertTrue(GrouperClientWs.mostRecentRequest,
15390 !GrouperClientWs.mostRecentRequest.contains("actions"));
15391 assertTrue(GrouperClientWs.mostRecentRequest,
15392 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15393 assertTrue(GrouperClientWs.mostRecentRequest,
15394 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15395 assertTrue(GrouperClientWs.mostRecentRequest,
15396 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15397 assertTrue(GrouperClientWs.mostRecentRequest,
15398 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15399 assertTrue(GrouperClientWs.mostRecentRequest,
15400 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15401 assertTrue(GrouperClientWs.mostRecentRequest,
15402 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15403 assertTrue(GrouperClientWs.mostRecentRequest,
15404 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15405 assertTrue(GrouperClientWs.mostRecentRequest,
15406 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15407 assertTrue(GrouperClientWs.mostRecentRequest,
15408 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15409 assertTrue(GrouperClientWs.mostRecentRequest,
15410 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15411 assertTrue(GrouperClientWs.mostRecentRequest,
15412 !GrouperClientWs.mostRecentRequest.contains("params"));
15413 assertTrue(GrouperClientWs.mostRecentRequest,
15414 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15415 assertTrue(GrouperClientWs.mostRecentRequest,
15416 !GrouperClientWs.mostRecentRequest.contains("values"));
15417 assertTrue(GrouperClientWs.mostRecentRequest,
15418 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15419 assertTrue(GrouperClientWs.mostRecentRequest,
15420 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15421 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15422 assertTrue(GrouperClientWs.mostRecentRequest,
15423 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15424 assertTrue(GrouperClientWs.mostRecentRequest,
15425 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15426 assertTrue(GrouperClientWs.mostRecentRequest,
15427 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15428 assertTrue(GrouperClientWs.mostRecentRequest,
15429 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15430 assertTrue(GrouperClientWs.mostRecentRequest,
15431 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15432 assertTrue(GrouperClientWs.mostRecentRequest,
15433 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15434 assertTrue(GrouperClientWs.mostRecentRequest,
15435 GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups")
15436 && GrouperClientWs.mostRecentRequest.contains(SubjectTestHelper.SUBJ0_ID));
15437
15438
15439 baos = new ByteArrayOutputStream();
15440 System.setOut(new PrintStream(baos));
15441
15442 GrouperClient.main(GrouperClientUtils.splitTrim(
15443 "--operation=assignAttributesWs --attributeAssignType=member --attributeAssignOperation=assign_attr " +
15444 "--attributeDefNameUuids=" + attributeDefName.getId() + " --owner0SubjectIdentifier=id.test.subject.0",
15445 " "));
15446
15447 attributeAssign = member.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15448
15449 System.out.flush();
15450 output = new String(baos.toByteArray());
15451
15452 System.setOut(systemOut);
15453
15454 outputLines = GrouperClientUtils.splitTrim(output, "\n");
15455
15456 outputLine = outputLines[0];
15457
15458 matcher = pattern.matcher(outputLines[0]);
15459
15460 assertTrue(outputLine, matcher.matches());
15461 assertEquals(outputLine, "0", matcher.group(1));
15462 assertEquals(outputLine, "member", matcher.group(2));
15463 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
15464 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15465 assertEquals(outputLine, "assign", matcher.group(5));
15466 assertEquals(outputLine, "none", matcher.group(6));
15467 assertEquals(outputLine, "T", matcher.group(7));
15468 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15469 assertEquals(outputLine, "F", matcher.group(9));
15470 assertEquals(outputLine, "F", matcher.group(10));
15471
15472 assertTrue(GrouperClientWs.mostRecentRequest,
15473 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15474 assertTrue(GrouperClientWs.mostRecentRequest,
15475 !GrouperClientWs.mostRecentRequest.contains("actions"));
15476 assertTrue(GrouperClientWs.mostRecentRequest,
15477 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15478 assertTrue(GrouperClientWs.mostRecentRequest,
15479 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15480 assertTrue(GrouperClientWs.mostRecentRequest,
15481 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15482 assertTrue(GrouperClientWs.mostRecentRequest,
15483 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15484 assertTrue(GrouperClientWs.mostRecentRequest,
15485 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15486 assertTrue(GrouperClientWs.mostRecentRequest,
15487 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15488 assertTrue(GrouperClientWs.mostRecentRequest,
15489 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15490 assertTrue(GrouperClientWs.mostRecentRequest,
15491 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15492 assertTrue(GrouperClientWs.mostRecentRequest,
15493 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15494 assertTrue(GrouperClientWs.mostRecentRequest,
15495 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15496 assertTrue(GrouperClientWs.mostRecentRequest,
15497 !GrouperClientWs.mostRecentRequest.contains("params"));
15498 assertTrue(GrouperClientWs.mostRecentRequest,
15499 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15500 assertTrue(GrouperClientWs.mostRecentRequest,
15501 !GrouperClientWs.mostRecentRequest.contains("values"));
15502 assertTrue(GrouperClientWs.mostRecentRequest,
15503 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15504 assertTrue(GrouperClientWs.mostRecentRequest,
15505 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15506 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
15507 assertTrue(GrouperClientWs.mostRecentRequest,
15508 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15509 assertTrue(GrouperClientWs.mostRecentRequest,
15510 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15511 assertTrue(GrouperClientWs.mostRecentRequest,
15512 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15513 assertTrue(GrouperClientWs.mostRecentRequest,
15514 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15515 assertTrue(GrouperClientWs.mostRecentRequest,
15516 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15517 assertTrue(GrouperClientWs.mostRecentRequest,
15518 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15519 assertTrue(GrouperClientWs.mostRecentRequest,
15520 GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups")
15521 && GrouperClientWs.mostRecentRequest.contains("id.test.subject.0"));
15522
15523
15524 } finally {
15525 System.setOut(systemOut);
15526 }
15527
15528 }
15529
15530
15531
15532
15533 public void testAssignAttributesAttributeDef() throws Exception {
15534
15535 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15536
15537 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15538
15539 attributeDef.setAssignToGroup(false);
15540 attributeDef.setAssignToAttributeDef(true);
15541 attributeDef.store();
15542
15543 AttributeDef attributeDefAssignTo = AttributeDefTest.exampleAttributeDefDb("test", "testAttributeDefAssignTo");
15544
15545
15546 AttributeAssign attributeAssign = null;
15547
15548 PrintStream systemOut = System.out;
15549
15550 ByteArrayOutputStream baos = new ByteArrayOutputStream();
15551 System.setOut(new PrintStream(baos));
15552
15553 try {
15554
15555 GrouperClient.main(GrouperClientUtils.splitTrim(
15556 "--operation=assignAttributesWs --attributeAssignType=attr_def --attributeAssignOperation=assign_attr " +
15557 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerAttributeDefNames=test:testAttributeDefAssignTo",
15558 " "));
15559
15560 attributeAssign = attributeDefAssignTo.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15561
15562 System.out.flush();
15563 String output = new String(baos.toByteArray());
15564
15565 System.setOut(systemOut);
15566
15567 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15568
15569
15570
15571 Pattern pattern = Pattern
15572 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15573 String outputLine = outputLines[0];
15574
15575 Matcher matcher = pattern.matcher(outputLines[0]);
15576
15577 assertTrue(outputLine, matcher.matches());
15578 assertEquals(outputLine, "0", matcher.group(1));
15579 assertEquals(outputLine, "attr_def", matcher.group(2));
15580 assertEquals(outputLine, attributeDefAssignTo.getName(), matcher.group(3));
15581 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15582 assertEquals(outputLine, "assign", matcher.group(5));
15583 assertEquals(outputLine, "none", matcher.group(6));
15584 assertEquals(outputLine, "T", matcher.group(7));
15585 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15586 assertEquals(outputLine, "T", matcher.group(9));
15587 assertEquals(outputLine, "F", matcher.group(10));
15588
15589 assertTrue(GrouperClientWs.mostRecentRequest,
15590 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15591 assertTrue(GrouperClientWs.mostRecentRequest,
15592 !GrouperClientWs.mostRecentRequest.contains("actions"));
15593 assertTrue(GrouperClientWs.mostRecentRequest,
15594 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15595 assertTrue(GrouperClientWs.mostRecentRequest,
15596 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15597 assertTrue(GrouperClientWs.mostRecentRequest,
15598 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15599 assertTrue(GrouperClientWs.mostRecentRequest,
15600 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15601 assertTrue(GrouperClientWs.mostRecentRequest,
15602 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15603 assertTrue(GrouperClientWs.mostRecentRequest,
15604 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15605 assertTrue(GrouperClientWs.mostRecentRequest,
15606 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15607 assertTrue(GrouperClientWs.mostRecentRequest,
15608 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15609 assertTrue(GrouperClientWs.mostRecentRequest,
15610 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15611 assertTrue(GrouperClientWs.mostRecentRequest,
15612 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15613 assertTrue(GrouperClientWs.mostRecentRequest,
15614 !GrouperClientWs.mostRecentRequest.contains("params"));
15615 assertTrue(GrouperClientWs.mostRecentRequest,
15616 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15617 assertTrue(GrouperClientWs.mostRecentRequest,
15618 !GrouperClientWs.mostRecentRequest.contains("values"));
15619 assertTrue(GrouperClientWs.mostRecentRequest,
15620 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15621 assertTrue(GrouperClientWs.mostRecentRequest,
15622 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15623 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15624 assertTrue(GrouperClientWs.mostRecentRequest,
15625 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15626 assertTrue(GrouperClientWs.mostRecentRequest,
15627 GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups")
15628 && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getName()));
15629 assertTrue(GrouperClientWs.mostRecentRequest,
15630 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15631 assertTrue(GrouperClientWs.mostRecentRequest,
15632 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15633 assertTrue(GrouperClientWs.mostRecentRequest,
15634 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15635 assertTrue(GrouperClientWs.mostRecentRequest,
15636 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15637 assertTrue(GrouperClientWs.mostRecentRequest,
15638 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15639
15640
15641 baos = new ByteArrayOutputStream();
15642 System.setOut(new PrintStream(baos));
15643
15644 GrouperClient.main(GrouperClientUtils.splitTrim(
15645 "--operation=assignAttributesWs --attributeAssignType=attr_def --attributeAssignOperation=assign_attr " +
15646 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerAttributeDefUuids=" + attributeDefAssignTo.getUuid(),
15647 " "));
15648
15649 attributeAssign = attributeDefAssignTo.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15650
15651 System.out.flush();
15652 output = new String(baos.toByteArray());
15653
15654 System.setOut(systemOut);
15655
15656 outputLines = GrouperClientUtils.splitTrim(output, "\n");
15657
15658 outputLine = outputLines[0];
15659
15660 matcher = pattern.matcher(outputLines[0]);
15661
15662 assertTrue(outputLine, matcher.matches());
15663 assertEquals(outputLine, "0", matcher.group(1));
15664 assertEquals(outputLine, "attr_def", matcher.group(2));
15665 assertEquals(outputLine, attributeDefAssignTo.getName(), matcher.group(3));
15666 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15667 assertEquals(outputLine, "assign", matcher.group(5));
15668 assertEquals(outputLine, "none", matcher.group(6));
15669 assertEquals(outputLine, "T", matcher.group(7));
15670 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15671 assertEquals(outputLine, "F", matcher.group(9));
15672 assertEquals(outputLine, "F", matcher.group(10));
15673
15674 assertTrue(GrouperClientWs.mostRecentRequest,
15675 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15676 assertTrue(GrouperClientWs.mostRecentRequest,
15677 !GrouperClientWs.mostRecentRequest.contains("actions"));
15678 assertTrue(GrouperClientWs.mostRecentRequest,
15679 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15680 assertTrue(GrouperClientWs.mostRecentRequest,
15681 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15682 assertTrue(GrouperClientWs.mostRecentRequest,
15683 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15684 assertTrue(GrouperClientWs.mostRecentRequest,
15685 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15686 assertTrue(GrouperClientWs.mostRecentRequest,
15687 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15688 assertTrue(GrouperClientWs.mostRecentRequest,
15689 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15690 assertTrue(GrouperClientWs.mostRecentRequest,
15691 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15692 assertTrue(GrouperClientWs.mostRecentRequest,
15693 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15694 assertTrue(GrouperClientWs.mostRecentRequest,
15695 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15696 assertTrue(GrouperClientWs.mostRecentRequest,
15697 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15698 assertTrue(GrouperClientWs.mostRecentRequest,
15699 !GrouperClientWs.mostRecentRequest.contains("params"));
15700 assertTrue(GrouperClientWs.mostRecentRequest,
15701 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15702 assertTrue(GrouperClientWs.mostRecentRequest,
15703 !GrouperClientWs.mostRecentRequest.contains("values"));
15704 assertTrue(GrouperClientWs.mostRecentRequest,
15705 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15706 assertTrue(GrouperClientWs.mostRecentRequest,
15707 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15708 && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getId()));
15709 assertTrue(GrouperClientWs.mostRecentRequest,
15710 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15711 assertTrue(GrouperClientWs.mostRecentRequest,
15712 GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups")
15713 && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getUuid()));
15714 assertTrue(GrouperClientWs.mostRecentRequest,
15715 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15716 assertTrue(GrouperClientWs.mostRecentRequest,
15717 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15718 assertTrue(GrouperClientWs.mostRecentRequest,
15719 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15720 assertTrue(GrouperClientWs.mostRecentRequest,
15721 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15722 assertTrue(GrouperClientWs.mostRecentRequest,
15723 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15724
15725
15726 baos = new ByteArrayOutputStream();
15727 System.setOut(new PrintStream(baos));
15728
15729 GrouperClient.main(GrouperClientUtils.splitTrim(
15730 "--operation=assignAttributesWs --attributeAssignType=attr_def --attributeAssignOperation=assign_attr " +
15731 "--attributeDefNameIdIndexes=" + attributeDefName.getIdIndex() + " --ownerAttributeDefIdIndexes=" + attributeDefAssignTo.getIdIndex(),
15732 " "));
15733
15734 attributeAssign = attributeDefAssignTo.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15735
15736 System.out.flush();
15737 output = new String(baos.toByteArray());
15738
15739 System.setOut(systemOut);
15740
15741 outputLines = GrouperClientUtils.splitTrim(output, "\n");
15742
15743 outputLine = outputLines[0];
15744
15745 matcher = pattern.matcher(outputLines[0]);
15746
15747 assertTrue(outputLine, matcher.matches());
15748 assertEquals(outputLine, "0", matcher.group(1));
15749 assertEquals(outputLine, "attr_def", matcher.group(2));
15750 assertEquals(outputLine, attributeDefAssignTo.getName(), matcher.group(3));
15751 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15752 assertEquals(outputLine, "assign", matcher.group(5));
15753 assertEquals(outputLine, "none", matcher.group(6));
15754 assertEquals(outputLine, "T", matcher.group(7));
15755 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15756 assertEquals(outputLine, "F", matcher.group(9));
15757 assertEquals(outputLine, "F", matcher.group(10));
15758
15759 assertTrue(GrouperClientWs.mostRecentRequest,
15760 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15761 assertTrue(GrouperClientWs.mostRecentRequest,
15762 !GrouperClientWs.mostRecentRequest.contains("actions"));
15763 assertTrue(GrouperClientWs.mostRecentRequest,
15764 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15765 assertTrue(GrouperClientWs.mostRecentRequest,
15766 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15767 assertTrue(GrouperClientWs.mostRecentRequest,
15768 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15769 assertTrue(GrouperClientWs.mostRecentRequest,
15770 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15771 assertTrue(GrouperClientWs.mostRecentRequest,
15772 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15773 assertTrue(GrouperClientWs.mostRecentRequest,
15774 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15775 assertTrue(GrouperClientWs.mostRecentRequest,
15776 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15777 assertTrue(GrouperClientWs.mostRecentRequest,
15778 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15779 assertTrue(GrouperClientWs.mostRecentRequest,
15780 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15781 assertTrue(GrouperClientWs.mostRecentRequest,
15782 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15783 assertTrue(GrouperClientWs.mostRecentRequest,
15784 !GrouperClientWs.mostRecentRequest.contains("params"));
15785 assertTrue(GrouperClientWs.mostRecentRequest,
15786 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15787 assertTrue(GrouperClientWs.mostRecentRequest,
15788 !GrouperClientWs.mostRecentRequest.contains("values"));
15789 assertTrue(GrouperClientWs.mostRecentRequest,
15790 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15791 assertTrue(GrouperClientWs.mostRecentRequest,
15792 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15793 && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getIdIndex().toString()));
15794 assertTrue(GrouperClientWs.mostRecentRequest,
15795 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15796 assertTrue(GrouperClientWs.mostRecentRequest,
15797 GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups")
15798 && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getIdIndex().toString()));
15799 assertTrue(GrouperClientWs.mostRecentRequest,
15800 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15801 assertTrue(GrouperClientWs.mostRecentRequest,
15802 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15803 assertTrue(GrouperClientWs.mostRecentRequest,
15804 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15805 assertTrue(GrouperClientWs.mostRecentRequest,
15806 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15807 assertTrue(GrouperClientWs.mostRecentRequest,
15808 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15809
15810
15811 } finally {
15812 System.setOut(systemOut);
15813 }
15814
15815 }
15816
15817
15818
15819
15820 public void testAssignAttributesMembership() throws Exception {
15821
15822 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15823
15824 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15825
15826 attributeDef.setAssignToGroup(false);
15827 attributeDef.setAssignToImmMembership(true);
15828 attributeDef.store();
15829
15830 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15831 .assignGroupNameToEdit("test:membershipTestAttrAssign").assignName("test:membershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
15832 .assignDescription("description").save();
15833
15834 group1.addMember(SubjectTestHelper.SUBJ0);
15835
15836 Membership membership = group1.getMemberships(FieldFinder.find("members", true)).iterator().next();
15837
15838
15839
15840 AttributeAssign attributeAssign = null;
15841
15842 PrintStream systemOut = System.out;
15843
15844 ByteArrayOutputStream baos = new ByteArrayOutputStream();
15845 System.setOut(new PrintStream(baos));
15846
15847 try {
15848
15849 GrouperClient.main(GrouperClientUtils.splitTrim(
15850 "--operation=assignAttributesWs --attributeAssignType=imm_mem --attributeAssignOperation=assign_attr " +
15851 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerMembershipUuids=" + membership.getUuid(),
15852 " "));
15853
15854 attributeAssign = membership.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15855
15856 System.out.flush();
15857 String output = new String(baos.toByteArray());
15858
15859 System.setOut(systemOut);
15860
15861 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15862
15863
15864
15865 Pattern pattern = Pattern
15866 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15867 String outputLine = outputLines[0];
15868
15869 Matcher matcher = pattern.matcher(outputLines[0]);
15870
15871 assertTrue(outputLine, matcher.matches());
15872 assertEquals(outputLine, "0", matcher.group(1));
15873 assertEquals(outputLine, "imm_mem", matcher.group(2));
15874 assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
15875 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15876 assertEquals(outputLine, "assign", matcher.group(5));
15877 assertEquals(outputLine, "none", matcher.group(6));
15878 assertEquals(outputLine, "T", matcher.group(7));
15879 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15880 assertEquals(outputLine, "T", matcher.group(9));
15881 assertEquals(outputLine, "F", matcher.group(10));
15882
15883 assertTrue(GrouperClientWs.mostRecentRequest,
15884 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15885 assertTrue(GrouperClientWs.mostRecentRequest,
15886 !GrouperClientWs.mostRecentRequest.contains("actions"));
15887 assertTrue(GrouperClientWs.mostRecentRequest,
15888 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15889 assertTrue(GrouperClientWs.mostRecentRequest,
15890 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15891 assertTrue(GrouperClientWs.mostRecentRequest,
15892 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15893 assertTrue(GrouperClientWs.mostRecentRequest,
15894 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15895 assertTrue(GrouperClientWs.mostRecentRequest,
15896 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15897 assertTrue(GrouperClientWs.mostRecentRequest,
15898 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15899 assertTrue(GrouperClientWs.mostRecentRequest,
15900 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15901 assertTrue(GrouperClientWs.mostRecentRequest,
15902 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15903 assertTrue(GrouperClientWs.mostRecentRequest,
15904 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15905 assertTrue(GrouperClientWs.mostRecentRequest,
15906 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15907 assertTrue(GrouperClientWs.mostRecentRequest,
15908 !GrouperClientWs.mostRecentRequest.contains("params"));
15909 assertTrue(GrouperClientWs.mostRecentRequest,
15910 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15911 assertTrue(GrouperClientWs.mostRecentRequest,
15912 !GrouperClientWs.mostRecentRequest.contains("values"));
15913 assertTrue(GrouperClientWs.mostRecentRequest,
15914 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15915 assertTrue(GrouperClientWs.mostRecentRequest,
15916 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15917 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15918 assertTrue(GrouperClientWs.mostRecentRequest,
15919 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15920 assertTrue(GrouperClientWs.mostRecentRequest,
15921 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15922 assertTrue(GrouperClientWs.mostRecentRequest,
15923 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15924 assertTrue(GrouperClientWs.mostRecentRequest,
15925 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15926 assertTrue(GrouperClientWs.mostRecentRequest,
15927 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups")
15928 && GrouperClientWs.mostRecentRequest.contains(membership.getUuid()));
15929 assertTrue(GrouperClientWs.mostRecentRequest,
15930 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15931 assertTrue(GrouperClientWs.mostRecentRequest,
15932 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15933
15934
15935 } finally {
15936 System.setOut(systemOut);
15937 }
15938
15939 }
15940
15941
15942
15943
15944 public void testAssignAttributesAnyMembership() throws Exception {
15945
15946 GrouperSession grouperSession = GrouperSession.startRootSession();
15947
15948 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15949
15950 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15951
15952 attributeDef.setAssignToGroup(false);
15953 attributeDef.setAssignToEffMembership(true);
15954 attributeDef.store();
15955
15956 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15957 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
15958 .assignDescription("description").save();
15959
15960 Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15961 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
15962 .assignDescription("description").save();
15963
15964
15965 group1.addMember(group2.toSubject());
15966 group2.addMember(SubjectTestHelper.SUBJ0);
15967
15968 Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, false);
15969
15970 Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
15971 GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
15972
15973
15974 AttributeAssign attributeAssign = null;
15975
15976 PrintStream systemOut = System.out;
15977
15978 ByteArrayOutputStream baos = new ByteArrayOutputStream();
15979 System.setOut(new PrintStream(baos));
15980
15981 try {
15982
15983 GrouperClient.main(GrouperClientUtils.splitTrim(
15984 "--operation=assignAttributesWs --attributeAssignType=any_mem --attributeAssignOperation=assign_attr " +
15985 "--attributeDefNameNames=test:testAttributeAssignDefName --ownerMembershipAny0SubjectId=" + member.getSubjectId()
15986 + " --ownerMembershipAny0GroupName=" + group1.getName(),
15987 " "));
15988
15989 attributeAssign = membership.getAttributeDelegateEffMship().retrieveAssignment("assign", attributeDefName, false, true);
15990
15991 System.out.flush();
15992 String output = new String(baos.toByteArray());
15993
15994 System.setOut(systemOut);
15995
15996 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15997
15998
15999
16000 Pattern pattern = Pattern
16001 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
16002 String outputLine = outputLines[0];
16003
16004 Matcher matcher = pattern.matcher(outputLines[0]);
16005
16006 assertTrue(outputLine, matcher.matches());
16007 assertEquals(outputLine, "0", matcher.group(1));
16008 assertEquals(outputLine, "any_mem", matcher.group(2));
16009 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
16010 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
16011 assertEquals(outputLine, "assign", matcher.group(5));
16012 assertEquals(outputLine, "none", matcher.group(6));
16013 assertEquals(outputLine, "T", matcher.group(7));
16014 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
16015 assertEquals(outputLine, "T", matcher.group(9));
16016 assertEquals(outputLine, "F", matcher.group(10));
16017
16018 assertTrue(GrouperClientWs.mostRecentRequest,
16019 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16020 assertTrue(GrouperClientWs.mostRecentRequest,
16021 !GrouperClientWs.mostRecentRequest.contains("actions"));
16022 assertTrue(GrouperClientWs.mostRecentRequest,
16023 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
16024 assertTrue(GrouperClientWs.mostRecentRequest,
16025 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
16026 assertTrue(GrouperClientWs.mostRecentRequest,
16027 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
16028 assertTrue(GrouperClientWs.mostRecentRequest,
16029 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
16030 assertTrue(GrouperClientWs.mostRecentRequest,
16031 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
16032 assertTrue(GrouperClientWs.mostRecentRequest,
16033 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
16034 assertTrue(GrouperClientWs.mostRecentRequest,
16035 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16036 assertTrue(GrouperClientWs.mostRecentRequest,
16037 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
16038 assertTrue(GrouperClientWs.mostRecentRequest,
16039 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16040 assertTrue(GrouperClientWs.mostRecentRequest,
16041 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16042 assertTrue(GrouperClientWs.mostRecentRequest,
16043 !GrouperClientWs.mostRecentRequest.contains("params"));
16044 assertTrue(GrouperClientWs.mostRecentRequest,
16045 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16046 assertTrue(GrouperClientWs.mostRecentRequest,
16047 !GrouperClientWs.mostRecentRequest.contains("values"));
16048 assertTrue(GrouperClientWs.mostRecentRequest,
16049 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16050 assertTrue(GrouperClientWs.mostRecentRequest,
16051 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
16052 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
16053 assertTrue(GrouperClientWs.mostRecentRequest,
16054 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
16055 assertTrue(GrouperClientWs.mostRecentRequest,
16056 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
16057 assertTrue(GrouperClientWs.mostRecentRequest,
16058 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
16059 assertTrue(GrouperClientWs.mostRecentRequest,
16060 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups")
16061 && GrouperClientWs.mostRecentRequest.contains(group1.getName())
16062 && GrouperClientWs.mostRecentRequest.contains(member.getSubjectId()));
16063 assertTrue(GrouperClientWs.mostRecentRequest,
16064 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
16065 assertTrue(GrouperClientWs.mostRecentRequest,
16066 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
16067 assertTrue(GrouperClientWs.mostRecentRequest,
16068 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
16069
16070
16071 } finally {
16072 System.setOut(systemOut);
16073 }
16074
16075 }
16076
16077
16078
16079
16080 public void testAssignAttributesMembershipAssn() throws Exception {
16081
16082 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
16083
16084 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
16085
16086 attributeDef.setAssignToGroup(false);
16087 attributeDef.setAssignToImmMembership(true);
16088 attributeDef.store();
16089
16090 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName2");
16091
16092 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
16093
16094 attributeDef2.setAssignToGroup(false);
16095 attributeDef2.setAssignToImmMembershipAssn(true);
16096 attributeDef2.store();
16097
16098 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
16099 .assignGroupNameToEdit("test:membershipTestAttrAssign").assignName("test:membershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
16100 .assignDescription("description").save();
16101
16102 group1.addMember(SubjectTestHelper.SUBJ0);
16103
16104 Membership membership = group1.getMemberships(FieldFinder.find("members", true)).iterator().next();
16105
16106 AttributeAssign attributeAssign = membership.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
16107
16108
16109 GrouperUtil.sleep(20000);
16110
16111 PrintStream systemOut = System.out;
16112
16113 ByteArrayOutputStream baos = new ByteArrayOutputStream();
16114 System.setOut(new PrintStream(baos));
16115
16116 try {
16117
16118 GrouperClient.main(GrouperClientUtils.splitTrim(
16119 "--operation=assignAttributesWs --attributeAssignType=imm_mem_asgn --attributeAssignOperation=assign_attr " +
16120 "--attributeDefNameNames=test:testAttributeAssignDefName2 --ownerAttributeAssignUuids=" + attributeAssign.getId(),
16121 " "));
16122
16123 AttributeAssign attributeAssign2 = attributeAssign.getAttributeDelegate().retrieveAssignment("assign", attributeDefName2, false, true);
16124
16125 System.out.flush();
16126 String output = new String(baos.toByteArray());
16127
16128 System.setOut(systemOut);
16129
16130 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
16131
16132
16133
16134 Pattern pattern = Pattern
16135 .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
16136 String outputLine = outputLines[0];
16137
16138 Matcher matcher = pattern.matcher(outputLines[0]);
16139
16140 assertTrue(outputLine, matcher.matches());
16141 assertEquals(outputLine, "0", matcher.group(1));
16142 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
16143 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
16144 assertEquals(outputLine, "test:testAttributeAssignDefName2", matcher.group(4));
16145 assertEquals(outputLine, "assign", matcher.group(5));
16146 assertEquals(outputLine, "none", matcher.group(6));
16147 assertEquals(outputLine, "T", matcher.group(7));
16148 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
16149 assertEquals(outputLine, "T", matcher.group(9));
16150 assertEquals(outputLine, "F", matcher.group(10));
16151
16152 assertTrue(GrouperClientWs.mostRecentRequest,
16153 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16154 assertTrue(GrouperClientWs.mostRecentRequest,
16155 !GrouperClientWs.mostRecentRequest.contains("actions"));
16156 assertTrue(GrouperClientWs.mostRecentRequest,
16157 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
16158 assertTrue(GrouperClientWs.mostRecentRequest,
16159 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
16160 assertTrue(GrouperClientWs.mostRecentRequest,
16161 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
16162 assertTrue(GrouperClientWs.mostRecentRequest,
16163 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
16164 assertTrue(GrouperClientWs.mostRecentRequest,
16165 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
16166 assertTrue(GrouperClientWs.mostRecentRequest,
16167 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
16168 assertTrue(GrouperClientWs.mostRecentRequest,
16169 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16170 assertTrue(GrouperClientWs.mostRecentRequest,
16171 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
16172 assertTrue(GrouperClientWs.mostRecentRequest,
16173 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16174 assertTrue(GrouperClientWs.mostRecentRequest,
16175 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16176 assertTrue(GrouperClientWs.mostRecentRequest,
16177 !GrouperClientWs.mostRecentRequest.contains("params"));
16178 assertTrue(GrouperClientWs.mostRecentRequest,
16179 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16180 assertTrue(GrouperClientWs.mostRecentRequest,
16181 !GrouperClientWs.mostRecentRequest.contains("values"));
16182 assertTrue(GrouperClientWs.mostRecentRequest,
16183 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16184 assertTrue(GrouperClientWs.mostRecentRequest,
16185 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16186 assertTrue(GrouperClientWs.mostRecentRequest,
16187 GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups")
16188 && GrouperClientWs.mostRecentRequest.contains(attributeAssign.getId()));
16189 assertTrue(GrouperClientWs.mostRecentRequest,
16190 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
16191 assertTrue(GrouperClientWs.mostRecentRequest,
16192 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
16193 assertTrue(GrouperClientWs.mostRecentRequest,
16194 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
16195 assertTrue(GrouperClientWs.mostRecentRequest,
16196 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
16197 assertTrue(GrouperClientWs.mostRecentRequest,
16198 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
16199 assertTrue(GrouperClientWs.mostRecentRequest,
16200 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
16201
16202
16203 } finally {
16204 System.setOut(systemOut);
16205 }
16206
16207 }
16208
16209
16210
16211
16212 public void testGetPermissionAssigns() throws Exception {
16213
16214 GrouperSession grouperSession = GrouperSession.startRootSession();
16215
16216 Stem aStem = Stem.saveStem(grouperSession, "aStem", null,"aStem", "a stem", "a stem description", null, false);
16217
16218
16219 Role role = aStem.addChildRole("role", "role");
16220 Role role2 = aStem.addChildRole("role2", "role2");
16221
16222 ((Group)role).addMember(SubjectTestHelper.SUBJ0);
16223 ((Group)role2).addMember(SubjectTestHelper.SUBJ1);
16224
16225 AttributeDef permissionDef = aStem.addChildAttributeDef("permissionDef", AttributeDefType.perm);
16226 permissionDef.setAssignToEffMembership(true);
16227 permissionDef.setAssignToGroup(true);
16228 permissionDef.store();
16229 AttributeDefName permissionDefName = aStem.addChildAttributeDefName(permissionDef, "permissionDefName", "permissionDefName");
16230 AttributeDefName permissionDefName2 = aStem.addChildAttributeDefName(permissionDef, "permissionDefName2", "permissionDefName2");
16231
16232 permissionDef.getAttributeDefActionDelegate().addAction("action");
16233 permissionDef.getAttributeDefActionDelegate().addAction("action2");
16234
16235
16236
16237
16238 role.getPermissionRoleDelegate().assignRolePermission("action", permissionDefName);
16239 role2.getPermissionRoleDelegate()
16240 .assignSubjectRolePermission("action2", permissionDefName2, SubjectTestHelper.SUBJ1);
16241
16242 PrintStream systemOut = System.out;
16243
16244 ByteArrayOutputStream baos = new ByteArrayOutputStream();
16245 System.setOut(new PrintStream(baos));
16246
16247 try {
16248
16249 GrouperClient.main(GrouperClientUtils.splitTrim(
16250 "--operation=getPermissionAssignmentsWs --attributeDefNames=aStem:permissionDef",
16251 " "));
16252 System.out.flush();
16253 String output = new String(baos.toByteArray());
16254
16255 System.setOut(systemOut);
16256
16257 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
16258
16259
16260
16261 Pattern pattern = Pattern
16262 .compile("^Index: (\\d+)\\: permissionType\\: (.+), role\\: (.+), subject\\: (.+), attributeDefNameName: (.+), action\\: (.+), allowedOverall\\: (.+), enabled\\: (T|F)$");
16263
16264 assertEquals(2, outputLines.length);
16265 String outputLine = outputLines[0];
16266
16267 Matcher matcher = pattern.matcher(outputLines[0]);
16268
16269 assertTrue(outputLine, matcher.matches());
16270 assertEquals(outputLine, "0", matcher.group(1));
16271 assertEquals(outputLine, "role", matcher.group(2));
16272 assertEquals(outputLine, "aStem:role", matcher.group(3));
16273 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16274 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16275 assertEquals(outputLine, "action", matcher.group(6));
16276 assertEquals(outputLine, "T", matcher.group(7));
16277 assertEquals(outputLine, "T", matcher.group(8));
16278
16279 outputLine = outputLines[1];
16280
16281 matcher = pattern.matcher(outputLines[1]);
16282
16283 assertTrue(outputLine, matcher.matches());
16284 assertEquals(outputLine, "1", matcher.group(1));
16285 assertEquals(outputLine, "role_subject", matcher.group(2));
16286 assertEquals(outputLine, "aStem:role2", matcher.group(3));
16287 assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
16288 assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
16289 assertEquals(outputLine, "action2", matcher.group(6));
16290 assertEquals(outputLine, "T", matcher.group(7));
16291 assertEquals(outputLine, "T", matcher.group(8));
16292
16293 assertTrue(GrouperClientWs.mostRecentRequest,
16294 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16295 assertTrue(GrouperClientWs.mostRecentRequest,
16296 !GrouperClientWs.mostRecentRequest.contains("actions"));
16297 assertTrue(GrouperClientWs.mostRecentRequest,
16298 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16299 assertTrue(GrouperClientWs.mostRecentRequest,
16300 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16301 assertTrue(GrouperClientWs.mostRecentRequest,
16302 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16303 assertTrue(GrouperClientWs.mostRecentRequest,
16304 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16305 assertTrue(GrouperClientWs.mostRecentRequest,
16306 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16307 assertTrue(GrouperClientWs.mostRecentRequest,
16308 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16309 assertTrue(GrouperClientWs.mostRecentRequest,
16310 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16311 assertTrue(GrouperClientWs.mostRecentRequest,
16312 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16313 assertTrue(GrouperClientWs.mostRecentRequest,
16314 !GrouperClientWs.mostRecentRequest.contains("params"));
16315 assertTrue(GrouperClientWs.mostRecentRequest,
16316 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16317 assertTrue(GrouperClientWs.mostRecentRequest,
16318 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16319 assertTrue(GrouperClientWs.mostRecentRequest,
16320 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
16321 assertTrue(GrouperClientWs.mostRecentRequest,
16322 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16323 assertTrue(GrouperClientWs.mostRecentRequest,
16324 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16325 assertTrue(GrouperClientWs.mostRecentRequest,
16326 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16327
16328
16329
16330
16331
16332
16333
16334 baos = new ByteArrayOutputStream();
16335 System.setOut(new PrintStream(baos));
16336
16337 GrouperClient.main(GrouperClientUtils.splitTrim(
16338 "--operation=getPermissionAssignmentsWs --attributeDefUuids=" + permissionDef.getId(),
16339 " "));
16340
16341
16342 System.out.flush();
16343 output = new String(baos.toByteArray());
16344
16345 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16346
16347 System.setOut(systemOut);
16348
16349
16350 assertEquals(2, outputLines.length);
16351 outputLine = outputLines[0];
16352
16353 matcher = pattern.matcher(outputLines[0]);
16354
16355 assertTrue(outputLine, matcher.matches());
16356 assertEquals(outputLine, "0", matcher.group(1));
16357 assertEquals(outputLine, "role", matcher.group(2));
16358 assertEquals(outputLine, "aStem:role", matcher.group(3));
16359 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16360 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16361 assertEquals(outputLine, "action", matcher.group(6));
16362 assertEquals(outputLine, "T", matcher.group(7));
16363 assertEquals(outputLine, "T", matcher.group(8));
16364
16365 outputLine = outputLines[1];
16366
16367 matcher = pattern.matcher(outputLines[1]);
16368
16369 assertTrue(outputLine, matcher.matches());
16370 assertEquals(outputLine, "1", matcher.group(1));
16371 assertEquals(outputLine, "role_subject", matcher.group(2));
16372 assertEquals(outputLine, "aStem:role2", matcher.group(3));
16373 assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
16374 assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
16375 assertEquals(outputLine, "action2", matcher.group(6));
16376 assertEquals(outputLine, "T", matcher.group(7));
16377 assertEquals(outputLine, "T", matcher.group(8));
16378
16379 assertTrue(GrouperClientWs.mostRecentRequest,
16380 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16381 assertTrue(GrouperClientWs.mostRecentRequest,
16382 !GrouperClientWs.mostRecentRequest.contains("actions"));
16383 assertTrue(GrouperClientWs.mostRecentRequest,
16384 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16385 assertTrue(GrouperClientWs.mostRecentRequest,
16386 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16387 assertTrue(GrouperClientWs.mostRecentRequest,
16388 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16389 assertTrue(GrouperClientWs.mostRecentRequest,
16390 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16391 assertTrue(GrouperClientWs.mostRecentRequest,
16392 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16393 assertTrue(GrouperClientWs.mostRecentRequest,
16394 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16395 assertTrue(GrouperClientWs.mostRecentRequest,
16396 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16397 assertTrue(GrouperClientWs.mostRecentRequest,
16398 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16399 assertTrue(GrouperClientWs.mostRecentRequest,
16400 !GrouperClientWs.mostRecentRequest.contains("params"));
16401 assertTrue(GrouperClientWs.mostRecentRequest,
16402 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16403 assertTrue(GrouperClientWs.mostRecentRequest,
16404 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16405 assertTrue(GrouperClientWs.mostRecentRequest,
16406 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
16407 assertTrue(GrouperClientWs.mostRecentRequest,
16408 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16409 assertTrue(GrouperClientWs.mostRecentRequest,
16410 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16411 assertTrue(GrouperClientWs.mostRecentRequest,
16412 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16413
16414
16415
16416
16417 baos = new ByteArrayOutputStream();
16418 System.setOut(new PrintStream(baos));
16419
16420 GrouperClient.main(GrouperClientUtils.splitTrim(
16421 "--operation=getPermissionAssignmentsWs --attributeDefIdIndexes=" + permissionDef.getIdIndex(),
16422 " "));
16423
16424
16425 System.out.flush();
16426 output = new String(baos.toByteArray());
16427
16428 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16429
16430 System.setOut(systemOut);
16431
16432
16433 assertEquals(2, outputLines.length);
16434 outputLine = outputLines[0];
16435
16436 matcher = pattern.matcher(outputLines[0]);
16437
16438 assertTrue(outputLine, matcher.matches());
16439 assertEquals(outputLine, "0", matcher.group(1));
16440 assertEquals(outputLine, "role", matcher.group(2));
16441 assertEquals(outputLine, "aStem:role", matcher.group(3));
16442 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16443 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16444 assertEquals(outputLine, "action", matcher.group(6));
16445 assertEquals(outputLine, "T", matcher.group(7));
16446 assertEquals(outputLine, "T", matcher.group(8));
16447
16448 outputLine = outputLines[1];
16449
16450 matcher = pattern.matcher(outputLines[1]);
16451
16452 assertTrue(outputLine, matcher.matches());
16453 assertEquals(outputLine, "1", matcher.group(1));
16454 assertEquals(outputLine, "role_subject", matcher.group(2));
16455 assertEquals(outputLine, "aStem:role2", matcher.group(3));
16456 assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
16457 assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
16458 assertEquals(outputLine, "action2", matcher.group(6));
16459 assertEquals(outputLine, "T", matcher.group(7));
16460 assertEquals(outputLine, "T", matcher.group(8));
16461
16462 assertTrue(GrouperClientWs.mostRecentRequest,
16463 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16464 assertTrue(GrouperClientWs.mostRecentRequest,
16465 !GrouperClientWs.mostRecentRequest.contains("actions"));
16466 assertTrue(GrouperClientWs.mostRecentRequest,
16467 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16468 assertTrue(GrouperClientWs.mostRecentRequest,
16469 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16470 assertTrue(GrouperClientWs.mostRecentRequest,
16471 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16472 assertTrue(GrouperClientWs.mostRecentRequest,
16473 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16474 assertTrue(GrouperClientWs.mostRecentRequest,
16475 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16476 assertTrue(GrouperClientWs.mostRecentRequest,
16477 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16478 assertTrue(GrouperClientWs.mostRecentRequest,
16479 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16480 assertTrue(GrouperClientWs.mostRecentRequest,
16481 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16482 assertTrue(GrouperClientWs.mostRecentRequest,
16483 !GrouperClientWs.mostRecentRequest.contains("params"));
16484 assertTrue(GrouperClientWs.mostRecentRequest,
16485 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16486 assertTrue(GrouperClientWs.mostRecentRequest,
16487 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16488 assertTrue(GrouperClientWs.mostRecentRequest,
16489 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
16490 assertTrue(GrouperClientWs.mostRecentRequest,
16491 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16492 assertTrue(GrouperClientWs.mostRecentRequest,
16493 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16494 assertTrue(GrouperClientWs.mostRecentRequest,
16495 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16496
16497
16498
16499
16500
16501
16502 baos = new ByteArrayOutputStream();
16503 System.setOut(new PrintStream(baos));
16504
16505 GrouperClient.main(GrouperClientUtils.splitTrim(
16506 "--operation=getPermissionAssignmentsWs --attributeDefNameNames=" + permissionDefName.getName(),
16507 " "));
16508
16509
16510 System.out.flush();
16511 output = new String(baos.toByteArray());
16512
16513 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16514
16515 System.setOut(systemOut);
16516
16517
16518 assertEquals(1, outputLines.length);
16519 outputLine = outputLines[0];
16520
16521 matcher = pattern.matcher(outputLines[0]);
16522
16523 assertTrue(outputLine, matcher.matches());
16524 assertEquals(outputLine, "0", matcher.group(1));
16525 assertEquals(outputLine, "role", matcher.group(2));
16526 assertEquals(outputLine, "aStem:role", matcher.group(3));
16527 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16528 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16529 assertEquals(outputLine, "action", matcher.group(6));
16530 assertEquals(outputLine, "T", matcher.group(7));
16531 assertEquals(outputLine, "T", matcher.group(8));
16532
16533 assertTrue(GrouperClientWs.mostRecentRequest,
16534 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16535 assertTrue(GrouperClientWs.mostRecentRequest,
16536 !GrouperClientWs.mostRecentRequest.contains("actions"));
16537 assertTrue(GrouperClientWs.mostRecentRequest,
16538 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16539 assertTrue(GrouperClientWs.mostRecentRequest,
16540 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16541 assertTrue(GrouperClientWs.mostRecentRequest,
16542 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16543 assertTrue(GrouperClientWs.mostRecentRequest,
16544 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16545 assertTrue(GrouperClientWs.mostRecentRequest,
16546 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16547 assertTrue(GrouperClientWs.mostRecentRequest,
16548 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16549 assertTrue(GrouperClientWs.mostRecentRequest,
16550 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16551 assertTrue(GrouperClientWs.mostRecentRequest,
16552 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16553 assertTrue(GrouperClientWs.mostRecentRequest,
16554 !GrouperClientWs.mostRecentRequest.contains("params"));
16555 assertTrue(GrouperClientWs.mostRecentRequest,
16556 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16557 assertTrue(GrouperClientWs.mostRecentRequest,
16558 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16559 assertTrue(GrouperClientWs.mostRecentRequest,
16560 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16561 assertTrue(GrouperClientWs.mostRecentRequest,
16562 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
16563 assertTrue(GrouperClientWs.mostRecentRequest,
16564 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16565 assertTrue(GrouperClientWs.mostRecentRequest,
16566 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16567
16568
16569
16570
16571
16572 baos = new ByteArrayOutputStream();
16573 System.setOut(new PrintStream(baos));
16574
16575 GrouperClient.main(GrouperClientUtils.splitTrim(
16576 "--operation=getPermissionAssignmentsWs --attributeDefNameUuids=" + permissionDefName.getId(),
16577 " "));
16578
16579
16580 System.out.flush();
16581 output = new String(baos.toByteArray());
16582
16583 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16584
16585 System.setOut(systemOut);
16586
16587
16588 assertEquals(1, outputLines.length);
16589 outputLine = outputLines[0];
16590
16591 matcher = pattern.matcher(outputLines[0]);
16592
16593 assertTrue(outputLine, matcher.matches());
16594 assertEquals(outputLine, "0", matcher.group(1));
16595 assertEquals(outputLine, "role", matcher.group(2));
16596 assertEquals(outputLine, "aStem:role", matcher.group(3));
16597 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16598 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16599 assertEquals(outputLine, "action", matcher.group(6));
16600 assertEquals(outputLine, "T", matcher.group(7));
16601 assertEquals(outputLine, "T", matcher.group(8));
16602
16603 assertTrue(GrouperClientWs.mostRecentRequest,
16604 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16605 assertTrue(GrouperClientWs.mostRecentRequest,
16606 !GrouperClientWs.mostRecentRequest.contains("actions"));
16607 assertTrue(GrouperClientWs.mostRecentRequest,
16608 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16609 assertTrue(GrouperClientWs.mostRecentRequest,
16610 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16611 assertTrue(GrouperClientWs.mostRecentRequest,
16612 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16613 assertTrue(GrouperClientWs.mostRecentRequest,
16614 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16615 assertTrue(GrouperClientWs.mostRecentRequest,
16616 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16617 assertTrue(GrouperClientWs.mostRecentRequest,
16618 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16619 assertTrue(GrouperClientWs.mostRecentRequest,
16620 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16621 assertTrue(GrouperClientWs.mostRecentRequest,
16622 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16623 assertTrue(GrouperClientWs.mostRecentRequest,
16624 !GrouperClientWs.mostRecentRequest.contains("params"));
16625 assertTrue(GrouperClientWs.mostRecentRequest,
16626 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16627 assertTrue(GrouperClientWs.mostRecentRequest,
16628 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16629 assertTrue(GrouperClientWs.mostRecentRequest,
16630 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16631 assertTrue(GrouperClientWs.mostRecentRequest,
16632 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
16633 assertTrue(GrouperClientWs.mostRecentRequest,
16634 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16635 assertTrue(GrouperClientWs.mostRecentRequest,
16636 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16637
16638
16639
16640
16641 baos = new ByteArrayOutputStream();
16642 System.setOut(new PrintStream(baos));
16643
16644 GrouperClient.main(GrouperClientUtils.splitTrim(
16645 "--operation=getPermissionAssignmentsWs --attributeDefNameIdIndexes=" + permissionDefName.getIdIndex(),
16646 " "));
16647
16648
16649 System.out.flush();
16650 output = new String(baos.toByteArray());
16651
16652 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16653
16654 System.setOut(systemOut);
16655
16656
16657 assertEquals(1, outputLines.length);
16658 outputLine = outputLines[0];
16659
16660 matcher = pattern.matcher(outputLines[0]);
16661
16662 assertTrue(outputLine, matcher.matches());
16663 assertEquals(outputLine, "0", matcher.group(1));
16664 assertEquals(outputLine, "role", matcher.group(2));
16665 assertEquals(outputLine, "aStem:role", matcher.group(3));
16666 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16667 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16668 assertEquals(outputLine, "action", matcher.group(6));
16669 assertEquals(outputLine, "T", matcher.group(7));
16670 assertEquals(outputLine, "T", matcher.group(8));
16671
16672 assertTrue(GrouperClientWs.mostRecentRequest,
16673 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16674 assertTrue(GrouperClientWs.mostRecentRequest,
16675 !GrouperClientWs.mostRecentRequest.contains("actions"));
16676 assertTrue(GrouperClientWs.mostRecentRequest,
16677 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16678 assertTrue(GrouperClientWs.mostRecentRequest,
16679 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16680 assertTrue(GrouperClientWs.mostRecentRequest,
16681 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16682 assertTrue(GrouperClientWs.mostRecentRequest,
16683 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16684 assertTrue(GrouperClientWs.mostRecentRequest,
16685 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16686 assertTrue(GrouperClientWs.mostRecentRequest,
16687 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16688 assertTrue(GrouperClientWs.mostRecentRequest,
16689 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16690 assertTrue(GrouperClientWs.mostRecentRequest,
16691 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16692 assertTrue(GrouperClientWs.mostRecentRequest,
16693 !GrouperClientWs.mostRecentRequest.contains("params"));
16694 assertTrue(GrouperClientWs.mostRecentRequest,
16695 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16696 assertTrue(GrouperClientWs.mostRecentRequest,
16697 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16698 assertTrue(GrouperClientWs.mostRecentRequest,
16699 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16700 assertTrue(GrouperClientWs.mostRecentRequest,
16701 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
16702 assertTrue(GrouperClientWs.mostRecentRequest,
16703 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16704 assertTrue(GrouperClientWs.mostRecentRequest,
16705 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16706
16707
16708
16709
16710
16711 baos = new ByteArrayOutputStream();
16712 System.setOut(new PrintStream(baos));
16713
16714 GrouperClient.main(GrouperClientUtils.splitTrim(
16715 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName(),
16716 " "));
16717
16718
16719 System.out.flush();
16720 output = new String(baos.toByteArray());
16721
16722 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16723
16724 System.setOut(systemOut);
16725
16726
16727 assertEquals(1, outputLines.length);
16728 outputLine = outputLines[0];
16729
16730 matcher = pattern.matcher(outputLines[0]);
16731
16732 assertTrue(outputLine, matcher.matches());
16733 assertEquals(outputLine, "0", matcher.group(1));
16734 assertEquals(outputLine, "role", matcher.group(2));
16735 assertEquals(outputLine, "aStem:role", matcher.group(3));
16736 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16737 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16738 assertEquals(outputLine, "action", matcher.group(6));
16739 assertEquals(outputLine, "T", matcher.group(7));
16740 assertEquals(outputLine, "T", matcher.group(8));
16741
16742 assertTrue(GrouperClientWs.mostRecentRequest,
16743 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16744 assertTrue(GrouperClientWs.mostRecentRequest,
16745 !GrouperClientWs.mostRecentRequest.contains("actions"));
16746 assertTrue(GrouperClientWs.mostRecentRequest,
16747 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16748 assertTrue(GrouperClientWs.mostRecentRequest,
16749 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16750 assertTrue(GrouperClientWs.mostRecentRequest,
16751 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16752 assertTrue(GrouperClientWs.mostRecentRequest,
16753 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16754 assertTrue(GrouperClientWs.mostRecentRequest,
16755 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16756 assertTrue(GrouperClientWs.mostRecentRequest,
16757 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16758 assertTrue(GrouperClientWs.mostRecentRequest,
16759 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16760 assertTrue(GrouperClientWs.mostRecentRequest,
16761 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16762 assertTrue(GrouperClientWs.mostRecentRequest,
16763 !GrouperClientWs.mostRecentRequest.contains("params"));
16764 assertTrue(GrouperClientWs.mostRecentRequest,
16765 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16766 assertTrue(GrouperClientWs.mostRecentRequest,
16767 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16768 assertTrue(GrouperClientWs.mostRecentRequest,
16769 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16770 assertTrue(GrouperClientWs.mostRecentRequest,
16771 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16772 assertTrue(GrouperClientWs.mostRecentRequest,
16773 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
16774 assertTrue(GrouperClientWs.mostRecentRequest,
16775 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16776
16777
16778
16779
16780
16781 baos = new ByteArrayOutputStream();
16782 System.setOut(new PrintStream(baos));
16783
16784 GrouperClient.main(GrouperClientUtils.splitTrim(
16785 "--operation=getPermissionAssignmentsWs --roleUuids=" + role.getId(),
16786 " "));
16787
16788
16789 System.out.flush();
16790 output = new String(baos.toByteArray());
16791
16792 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16793
16794 System.setOut(systemOut);
16795
16796
16797 assertEquals(1, outputLines.length);
16798 outputLine = outputLines[0];
16799
16800 matcher = pattern.matcher(outputLines[0]);
16801
16802 assertTrue(outputLine, matcher.matches());
16803 assertEquals(outputLine, "0", matcher.group(1));
16804 assertEquals(outputLine, "role", matcher.group(2));
16805 assertEquals(outputLine, "aStem:role", matcher.group(3));
16806 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16807 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16808 assertEquals(outputLine, "action", matcher.group(6));
16809 assertEquals(outputLine, "T", matcher.group(7));
16810 assertEquals(outputLine, "T", matcher.group(8));
16811
16812 assertTrue(GrouperClientWs.mostRecentRequest,
16813 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16814 assertTrue(GrouperClientWs.mostRecentRequest,
16815 !GrouperClientWs.mostRecentRequest.contains("actions"));
16816 assertTrue(GrouperClientWs.mostRecentRequest,
16817 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16818 assertTrue(GrouperClientWs.mostRecentRequest,
16819 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16820 assertTrue(GrouperClientWs.mostRecentRequest,
16821 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16822 assertTrue(GrouperClientWs.mostRecentRequest,
16823 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16824 assertTrue(GrouperClientWs.mostRecentRequest,
16825 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16826 assertTrue(GrouperClientWs.mostRecentRequest,
16827 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16828 assertTrue(GrouperClientWs.mostRecentRequest,
16829 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16830 assertTrue(GrouperClientWs.mostRecentRequest,
16831 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16832 assertTrue(GrouperClientWs.mostRecentRequest,
16833 !GrouperClientWs.mostRecentRequest.contains("params"));
16834 assertTrue(GrouperClientWs.mostRecentRequest,
16835 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16836 assertTrue(GrouperClientWs.mostRecentRequest,
16837 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16838 assertTrue(GrouperClientWs.mostRecentRequest,
16839 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16840 assertTrue(GrouperClientWs.mostRecentRequest,
16841 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16842 assertTrue(GrouperClientWs.mostRecentRequest,
16843 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
16844 assertTrue(GrouperClientWs.mostRecentRequest,
16845 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16846
16847
16848
16849
16850
16851
16852 baos = new ByteArrayOutputStream();
16853 System.setOut(new PrintStream(baos));
16854
16855 GrouperClient.main(GrouperClientUtils.splitTrim(
16856 "--operation=getPermissionAssignmentsWs --roleIdIndexes=" + role.getIdIndex(),
16857 " "));
16858
16859
16860 System.out.flush();
16861 output = new String(baos.toByteArray());
16862
16863 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16864
16865 System.setOut(systemOut);
16866
16867
16868 assertEquals(1, outputLines.length);
16869 outputLine = outputLines[0];
16870
16871 matcher = pattern.matcher(outputLines[0]);
16872
16873 assertTrue(outputLine, matcher.matches());
16874 assertEquals(outputLine, "0", matcher.group(1));
16875 assertEquals(outputLine, "role", matcher.group(2));
16876 assertEquals(outputLine, "aStem:role", matcher.group(3));
16877 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16878 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16879 assertEquals(outputLine, "action", matcher.group(6));
16880 assertEquals(outputLine, "T", matcher.group(7));
16881 assertEquals(outputLine, "T", matcher.group(8));
16882
16883 assertTrue(GrouperClientWs.mostRecentRequest,
16884 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16885 assertTrue(GrouperClientWs.mostRecentRequest,
16886 !GrouperClientWs.mostRecentRequest.contains("actions"));
16887 assertTrue(GrouperClientWs.mostRecentRequest,
16888 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16889 assertTrue(GrouperClientWs.mostRecentRequest,
16890 !GrouperClientWs.mostRecentRequest.contains("enabled"));
16891 assertTrue(GrouperClientWs.mostRecentRequest,
16892 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16893 assertTrue(GrouperClientWs.mostRecentRequest,
16894 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16895 assertTrue(GrouperClientWs.mostRecentRequest,
16896 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16897 assertTrue(GrouperClientWs.mostRecentRequest,
16898 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16899 assertTrue(GrouperClientWs.mostRecentRequest,
16900 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16901 assertTrue(GrouperClientWs.mostRecentRequest,
16902 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16903 assertTrue(GrouperClientWs.mostRecentRequest,
16904 !GrouperClientWs.mostRecentRequest.contains("params"));
16905 assertTrue(GrouperClientWs.mostRecentRequest,
16906 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16907 assertTrue(GrouperClientWs.mostRecentRequest,
16908 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16909 assertTrue(GrouperClientWs.mostRecentRequest,
16910 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16911 assertTrue(GrouperClientWs.mostRecentRequest,
16912 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16913 assertTrue(GrouperClientWs.mostRecentRequest,
16914 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
16915 assertTrue(GrouperClientWs.mostRecentRequest,
16916 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16917
16918
16919
16920
16921 baos = new ByteArrayOutputStream();
16922 System.setOut(new PrintStream(baos));
16923
16924 GrouperClient.main(GrouperClientUtils.splitTrim(
16925 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --enabled=F",
16926 " "));
16927
16928 System.out.flush();
16929 output = new String(baos.toByteArray());
16930
16931 System.setOut(systemOut);
16932
16933 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16934
16935 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
16936
16937
16938 assertTrue(GrouperClientWs.mostRecentRequest,
16939 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16940 assertTrue(GrouperClientWs.mostRecentRequest,
16941 !GrouperClientWs.mostRecentRequest.contains("actions"));
16942 assertTrue(GrouperClientWs.mostRecentRequest,
16943 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16944 assertTrue(GrouperClientWs.mostRecentRequest,
16945 GrouperClientWs.mostRecentRequest.contains("enabled"));
16946 assertTrue(GrouperClientWs.mostRecentRequest,
16947 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16948 assertTrue(GrouperClientWs.mostRecentRequest,
16949 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16950 assertTrue(GrouperClientWs.mostRecentRequest,
16951 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16952 assertTrue(GrouperClientWs.mostRecentRequest,
16953 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16954 assertTrue(GrouperClientWs.mostRecentRequest,
16955 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16956 assertTrue(GrouperClientWs.mostRecentRequest,
16957 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16958 assertTrue(GrouperClientWs.mostRecentRequest,
16959 !GrouperClientWs.mostRecentRequest.contains("params"));
16960 assertTrue(GrouperClientWs.mostRecentRequest,
16961 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16962 assertTrue(GrouperClientWs.mostRecentRequest,
16963 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16964 assertTrue(GrouperClientWs.mostRecentRequest,
16965 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16966 assertTrue(GrouperClientWs.mostRecentRequest,
16967 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16968 assertTrue(GrouperClientWs.mostRecentRequest,
16969 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
16970 assertTrue(GrouperClientWs.mostRecentRequest,
16971 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16972
16973
16974
16975
16976 baos = new ByteArrayOutputStream();
16977 System.setOut(new PrintStream(baos));
16978
16979 GrouperClient.main(GrouperClientUtils.splitTrim(
16980 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --actions=a",
16981 " "));
16982
16983 System.out.flush();
16984 output = new String(baos.toByteArray());
16985
16986 System.setOut(systemOut);
16987
16988 outputLines = GrouperClientUtils.splitTrim(output, "\n");
16989
16990 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
16991
16992
16993 assertTrue(GrouperClientWs.mostRecentRequest,
16994 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16995 assertTrue(GrouperClientWs.mostRecentRequest,
16996 GrouperClientWs.mostRecentRequest.contains("actions"));
16997 assertTrue(GrouperClientWs.mostRecentRequest,
16998 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16999 assertTrue(GrouperClientWs.mostRecentRequest,
17000 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17001 assertTrue(GrouperClientWs.mostRecentRequest,
17002 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17003 assertTrue(GrouperClientWs.mostRecentRequest,
17004 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17005 assertTrue(GrouperClientWs.mostRecentRequest,
17006 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17007 assertTrue(GrouperClientWs.mostRecentRequest,
17008 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17009 assertTrue(GrouperClientWs.mostRecentRequest,
17010 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17011 assertTrue(GrouperClientWs.mostRecentRequest,
17012 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17013 assertTrue(GrouperClientWs.mostRecentRequest,
17014 !GrouperClientWs.mostRecentRequest.contains("params"));
17015 assertTrue(GrouperClientWs.mostRecentRequest,
17016 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17017 assertTrue(GrouperClientWs.mostRecentRequest,
17018 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17019 assertTrue(GrouperClientWs.mostRecentRequest,
17020 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17021 assertTrue(GrouperClientWs.mostRecentRequest,
17022 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17023 assertTrue(GrouperClientWs.mostRecentRequest,
17024 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17025 assertTrue(GrouperClientWs.mostRecentRequest,
17026 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17027
17028
17029
17030
17031 baos = new ByteArrayOutputStream();
17032 System.setOut(new PrintStream(baos));
17033
17034 GrouperClient.main(GrouperClientUtils.splitTrim(
17035 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeAttributeAssignments=T",
17036 " "));
17037
17038 System.out.flush();
17039 output = new String(baos.toByteArray());
17040
17041 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17042
17043 System.setOut(systemOut);
17044
17045
17046 assertEquals(1, outputLines.length);
17047 outputLine = outputLines[0];
17048
17049 matcher = pattern.matcher(outputLines[0]);
17050
17051 assertTrue(outputLine, matcher.matches());
17052 assertEquals(outputLine, "0", matcher.group(1));
17053 assertEquals(outputLine, "role", matcher.group(2));
17054 assertEquals(outputLine, "aStem:role", matcher.group(3));
17055 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17056 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17057 assertEquals(outputLine, "action", matcher.group(6));
17058 assertEquals(outputLine, "T", matcher.group(7));
17059 assertEquals(outputLine, "T", matcher.group(8));
17060
17061
17062 assertTrue(GrouperClientWs.mostRecentRequest,
17063 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17064 assertTrue(GrouperClientWs.mostRecentRequest,
17065 !GrouperClientWs.mostRecentRequest.contains("actions"));
17066 assertTrue(GrouperClientWs.mostRecentRequest,
17067 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17068 assertTrue(GrouperClientWs.mostRecentRequest,
17069 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17070 assertTrue(GrouperClientWs.mostRecentRequest,
17071 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17072 assertTrue(GrouperClientWs.mostRecentRequest,
17073 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17074 assertTrue(GrouperClientWs.mostRecentRequest,
17075 GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17076 assertTrue(GrouperClientWs.mostRecentResponse,
17077 GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
17078 assertTrue(GrouperClientWs.mostRecentRequest,
17079 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17080 assertTrue(GrouperClientWs.mostRecentRequest,
17081 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17082 assertTrue(GrouperClientWs.mostRecentRequest,
17083 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17084 assertTrue(GrouperClientWs.mostRecentRequest,
17085 !GrouperClientWs.mostRecentRequest.contains("params"));
17086 assertTrue(GrouperClientWs.mostRecentRequest,
17087 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17088 assertTrue(GrouperClientWs.mostRecentRequest,
17089 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17090 assertTrue(GrouperClientWs.mostRecentRequest,
17091 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17092 assertTrue(GrouperClientWs.mostRecentRequest,
17093 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17094 assertTrue(GrouperClientWs.mostRecentRequest,
17095 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17096 assertTrue(GrouperClientWs.mostRecentRequest,
17097 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17098
17099
17100
17101
17102 baos = new ByteArrayOutputStream();
17103 System.setOut(new PrintStream(baos));
17104
17105 GrouperClient.main(GrouperClientUtils.splitTrim(
17106 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeAttributeAssignments=T --includeAssignmentsOnAssignments=T",
17107 " "));
17108
17109 System.out.flush();
17110 output = new String(baos.toByteArray());
17111
17112 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17113
17114 System.setOut(systemOut);
17115
17116
17117 assertEquals(1, outputLines.length);
17118 outputLine = outputLines[0];
17119
17120 matcher = pattern.matcher(outputLines[0]);
17121
17122 assertTrue(outputLine, matcher.matches());
17123 assertEquals(outputLine, "0", matcher.group(1));
17124 assertEquals(outputLine, "role", matcher.group(2));
17125 assertEquals(outputLine, "aStem:role", matcher.group(3));
17126 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17127 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17128 assertEquals(outputLine, "action", matcher.group(6));
17129 assertEquals(outputLine, "T", matcher.group(7));
17130 assertEquals(outputLine, "T", matcher.group(8));
17131
17132
17133 assertTrue(GrouperClientWs.mostRecentRequest,
17134 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17135 assertTrue(GrouperClientWs.mostRecentRequest,
17136 !GrouperClientWs.mostRecentRequest.contains("actions"));
17137 assertTrue(GrouperClientWs.mostRecentRequest,
17138 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17139 assertTrue(GrouperClientWs.mostRecentRequest,
17140 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17141 assertTrue(GrouperClientWs.mostRecentRequest,
17142 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17143 assertTrue(GrouperClientWs.mostRecentRequest,
17144 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17145 assertTrue(GrouperClientWs.mostRecentRequest,
17146 GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17147 assertTrue(GrouperClientWs.mostRecentResponse,
17148 GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
17149 assertTrue(GrouperClientWs.mostRecentRequest,
17150 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17151 assertTrue(GrouperClientWs.mostRecentRequest,
17152 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17153 assertTrue(GrouperClientWs.mostRecentRequest,
17154 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17155 assertTrue(GrouperClientWs.mostRecentRequest,
17156 !GrouperClientWs.mostRecentRequest.contains("params"));
17157 assertTrue(GrouperClientWs.mostRecentRequest,
17158 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17159 assertTrue(GrouperClientWs.mostRecentRequest,
17160 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17161 assertTrue(GrouperClientWs.mostRecentRequest,
17162 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17163 assertTrue(GrouperClientWs.mostRecentRequest,
17164 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17165 assertTrue(GrouperClientWs.mostRecentRequest,
17166 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17167 assertTrue(GrouperClientWs.mostRecentRequest,
17168 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17169 assertTrue(GrouperClientWs.mostRecentResponse,
17170 !GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
17171
17172
17173
17174
17175 baos = new ByteArrayOutputStream();
17176 System.setOut(new PrintStream(baos));
17177
17178 GrouperClient.main(GrouperClientUtils.splitTrim(
17179 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includePermissionAssignDetail=T",
17180 " "));
17181
17182 System.out.flush();
17183 output = new String(baos.toByteArray());
17184
17185 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17186
17187 System.setOut(systemOut);
17188
17189
17190 assertEquals(1, outputLines.length);
17191 outputLine = outputLines[0];
17192
17193 matcher = pattern.matcher(outputLines[0]);
17194
17195 assertTrue(outputLine, matcher.matches());
17196 assertEquals(outputLine, "0", matcher.group(1));
17197 assertEquals(outputLine, "role", matcher.group(2));
17198 assertEquals(outputLine, "aStem:role", matcher.group(3));
17199 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17200 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17201 assertEquals(outputLine, "action", matcher.group(6));
17202 assertEquals(outputLine, "T", matcher.group(7));
17203 assertEquals(outputLine, "T", matcher.group(8));
17204
17205
17206 assertTrue(GrouperClientWs.mostRecentRequest,
17207 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17208 assertTrue(GrouperClientWs.mostRecentRequest,
17209 !GrouperClientWs.mostRecentRequest.contains("actions"));
17210 assertTrue(GrouperClientWs.mostRecentRequest,
17211 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17212 assertTrue(GrouperClientWs.mostRecentRequest,
17213 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17214 assertTrue(GrouperClientWs.mostRecentRequest,
17215 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17216 assertTrue(GrouperClientWs.mostRecentRequest,
17217 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17218 assertTrue(GrouperClientWs.mostRecentRequest,
17219 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17220 assertTrue(GrouperClientWs.mostRecentResponse,
17221 GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
17222 assertTrue(GrouperClientWs.mostRecentRequest,
17223 GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17224 assertTrue(GrouperClientWs.mostRecentRequest,
17225 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17226 assertTrue(GrouperClientWs.mostRecentRequest,
17227 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17228 assertTrue(GrouperClientWs.mostRecentRequest,
17229 !GrouperClientWs.mostRecentRequest.contains("params"));
17230 assertTrue(GrouperClientWs.mostRecentRequest,
17231 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17232 assertTrue(GrouperClientWs.mostRecentRequest,
17233 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17234 assertTrue(GrouperClientWs.mostRecentRequest,
17235 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17236 assertTrue(GrouperClientWs.mostRecentRequest,
17237 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17238 assertTrue(GrouperClientWs.mostRecentRequest,
17239 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17240 assertTrue(GrouperClientWs.mostRecentRequest,
17241 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17242 assertTrue(GrouperClientWs.mostRecentResponse,
17243 !GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
17244
17245
17246
17247
17248 baos = new ByteArrayOutputStream();
17249 System.setOut(new PrintStream(baos));
17250
17251 GrouperClient.main(GrouperClientUtils.splitTrim(
17252 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeAttributeDefNames=T",
17253 " "));
17254
17255 System.out.flush();
17256 output = new String(baos.toByteArray());
17257
17258 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17259
17260 System.setOut(systemOut);
17261
17262
17263 assertEquals(1, outputLines.length);
17264 outputLine = outputLines[0];
17265
17266 matcher = pattern.matcher(outputLines[0]);
17267
17268 assertTrue(outputLine, matcher.matches());
17269 assertEquals(outputLine, "0", matcher.group(1));
17270 assertEquals(outputLine, "role", matcher.group(2));
17271 assertEquals(outputLine, "aStem:role", matcher.group(3));
17272 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17273 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17274 assertEquals(outputLine, "action", matcher.group(6));
17275 assertEquals(outputLine, "T", matcher.group(7));
17276 assertEquals(outputLine, "T", matcher.group(8));
17277
17278
17279 assertTrue(GrouperClientWs.mostRecentRequest,
17280 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17281 assertTrue(GrouperClientWs.mostRecentRequest,
17282 !GrouperClientWs.mostRecentRequest.contains("actions"));
17283 assertTrue(GrouperClientWs.mostRecentRequest,
17284 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17285 assertTrue(GrouperClientWs.mostRecentRequest,
17286 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17287 assertTrue(GrouperClientWs.mostRecentRequest,
17288 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17289 assertTrue(GrouperClientWs.mostRecentRequest,
17290 GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17291 assertTrue(GrouperClientWs.mostRecentRequest,
17292 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17293 assertTrue(GrouperClientWs.mostRecentResponse,
17294 GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
17295 assertTrue(GrouperClientWs.mostRecentRequest,
17296 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17297 assertTrue(GrouperClientWs.mostRecentRequest,
17298 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17299 assertTrue(GrouperClientWs.mostRecentRequest,
17300 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17301 assertTrue(GrouperClientWs.mostRecentRequest,
17302 !GrouperClientWs.mostRecentRequest.contains("params"));
17303 assertTrue(GrouperClientWs.mostRecentRequest,
17304 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17305 assertTrue(GrouperClientWs.mostRecentRequest,
17306 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17307 assertTrue(GrouperClientWs.mostRecentRequest,
17308 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17309 assertTrue(GrouperClientWs.mostRecentRequest,
17310 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17311 assertTrue(GrouperClientWs.mostRecentRequest,
17312 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17313 assertTrue(GrouperClientWs.mostRecentRequest,
17314 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17315
17316
17317
17318
17319 baos = new ByteArrayOutputStream();
17320 System.setOut(new PrintStream(baos));
17321
17322 GrouperClient.main(GrouperClientUtils.splitTrim(
17323 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeGroupDetail=T",
17324 " "));
17325
17326 System.out.flush();
17327 output = new String(baos.toByteArray());
17328
17329 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17330
17331 System.setOut(systemOut);
17332
17333
17334 assertEquals(1, outputLines.length);
17335 outputLine = outputLines[0];
17336
17337 matcher = pattern.matcher(outputLines[0]);
17338
17339 assertTrue(outputLine, matcher.matches());
17340 assertEquals(outputLine, "0", matcher.group(1));
17341 assertEquals(outputLine, "role", matcher.group(2));
17342 assertEquals(outputLine, "aStem:role", matcher.group(3));
17343 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17344 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17345 assertEquals(outputLine, "action", matcher.group(6));
17346 assertEquals(outputLine, "T", matcher.group(7));
17347 assertEquals(outputLine, "T", matcher.group(8));
17348
17349
17350 assertTrue(GrouperClientWs.mostRecentRequest,
17351 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17352 assertTrue(GrouperClientWs.mostRecentRequest,
17353 !GrouperClientWs.mostRecentRequest.contains("actions"));
17354 assertTrue(GrouperClientWs.mostRecentRequest,
17355 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17356 assertTrue(GrouperClientWs.mostRecentRequest,
17357 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17358 assertTrue(GrouperClientWs.mostRecentRequest,
17359 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17360 assertTrue(GrouperClientWs.mostRecentRequest,
17361 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17362 assertTrue(GrouperClientWs.mostRecentRequest,
17363 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17364 assertTrue(GrouperClientWs.mostRecentResponse,
17365 GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17366 assertTrue(GrouperClientWs.mostRecentRequest,
17367 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17368 assertTrue(GrouperClientWs.mostRecentRequest,
17369 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17370 assertTrue(GrouperClientWs.mostRecentRequest,
17371 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17372 assertTrue(GrouperClientWs.mostRecentRequest,
17373 !GrouperClientWs.mostRecentRequest.contains("params"));
17374 assertTrue(GrouperClientWs.mostRecentRequest,
17375 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17376 assertTrue(GrouperClientWs.mostRecentRequest,
17377 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17378 assertTrue(GrouperClientWs.mostRecentRequest,
17379 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17380 assertTrue(GrouperClientWs.mostRecentRequest,
17381 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17382 assertTrue(GrouperClientWs.mostRecentRequest,
17383 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17384 assertTrue(GrouperClientWs.mostRecentRequest,
17385 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17386
17387
17388
17389
17390 baos = new ByteArrayOutputStream();
17391 System.setOut(new PrintStream(baos));
17392
17393 GrouperClient.main(GrouperClientUtils.splitTrim(
17394 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeSubjectDetail=T",
17395 " "));
17396
17397 System.out.flush();
17398 output = new String(baos.toByteArray());
17399
17400 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17401
17402 System.setOut(systemOut);
17403
17404
17405 assertEquals(1, outputLines.length);
17406 outputLine = outputLines[0];
17407
17408 matcher = pattern.matcher(outputLines[0]);
17409
17410 assertTrue(outputLine, matcher.matches());
17411 assertEquals(outputLine, "0", matcher.group(1));
17412 assertEquals(outputLine, "role", matcher.group(2));
17413 assertEquals(outputLine, "aStem:role", matcher.group(3));
17414 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17415 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17416 assertEquals(outputLine, "action", matcher.group(6));
17417 assertEquals(outputLine, "T", matcher.group(7));
17418 assertEquals(outputLine, "T", matcher.group(8));
17419
17420
17421 assertTrue(GrouperClientWs.mostRecentRequest,
17422 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17423 assertTrue(GrouperClientWs.mostRecentRequest,
17424 !GrouperClientWs.mostRecentRequest.contains("actions"));
17425 assertTrue(GrouperClientWs.mostRecentRequest,
17426 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17427 assertTrue(GrouperClientWs.mostRecentRequest,
17428 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17429 assertTrue(GrouperClientWs.mostRecentRequest,
17430 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17431 assertTrue(GrouperClientWs.mostRecentRequest,
17432 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17433 assertTrue(GrouperClientWs.mostRecentRequest,
17434 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17435 assertTrue(GrouperClientWs.mostRecentResponse,
17436 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17437 assertTrue(GrouperClientWs.mostRecentRequest,
17438 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17439 assertTrue(GrouperClientWs.mostRecentRequest,
17440 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17441 assertTrue(GrouperClientWs.mostRecentRequest,
17442 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17443 assertTrue(GrouperClientWs.mostRecentRequest,
17444 !GrouperClientWs.mostRecentRequest.contains("params"));
17445 assertTrue(GrouperClientWs.mostRecentRequest,
17446 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17447 assertTrue(GrouperClientWs.mostRecentRequest,
17448 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17449 assertTrue(GrouperClientWs.mostRecentRequest,
17450 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17451 assertTrue(GrouperClientWs.mostRecentRequest,
17452 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17453 assertTrue(GrouperClientWs.mostRecentRequest,
17454 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17455 assertTrue(GrouperClientWs.mostRecentRequest,
17456 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17457
17458
17459
17460
17461 baos = new ByteArrayOutputStream();
17462 System.setOut(new PrintStream(baos));
17463
17464 GrouperClient.main(GrouperClientUtils.splitTrim(
17465 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --subjectAttributeNames=abc",
17466 " "));
17467
17468 System.out.flush();
17469 output = new String(baos.toByteArray());
17470
17471 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17472
17473 System.setOut(systemOut);
17474
17475
17476 assertEquals(1, outputLines.length);
17477 outputLine = outputLines[0];
17478
17479 matcher = pattern.matcher(outputLines[0]);
17480
17481 assertTrue(outputLine, matcher.matches());
17482 assertEquals(outputLine, "0", matcher.group(1));
17483 assertEquals(outputLine, "role", matcher.group(2));
17484 assertEquals(outputLine, "aStem:role", matcher.group(3));
17485 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17486 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17487 assertEquals(outputLine, "action", matcher.group(6));
17488 assertEquals(outputLine, "T", matcher.group(7));
17489 assertEquals(outputLine, "T", matcher.group(8));
17490
17491
17492 assertTrue(GrouperClientWs.mostRecentRequest,
17493 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17494 assertTrue(GrouperClientWs.mostRecentRequest,
17495 !GrouperClientWs.mostRecentRequest.contains("actions"));
17496 assertTrue(GrouperClientWs.mostRecentRequest,
17497 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17498 assertTrue(GrouperClientWs.mostRecentRequest,
17499 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17500 assertTrue(GrouperClientWs.mostRecentRequest,
17501 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17502 assertTrue(GrouperClientWs.mostRecentRequest,
17503 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17504 assertTrue(GrouperClientWs.mostRecentRequest,
17505 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17506 assertTrue(GrouperClientWs.mostRecentResponse,
17507 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17508 assertTrue(GrouperClientWs.mostRecentRequest,
17509 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17510 assertTrue(GrouperClientWs.mostRecentRequest,
17511 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17512 assertTrue(GrouperClientWs.mostRecentRequest,
17513 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17514 assertTrue(GrouperClientWs.mostRecentRequest,
17515 !GrouperClientWs.mostRecentRequest.contains("params"));
17516 assertTrue(GrouperClientWs.mostRecentRequest,
17517 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames") && GrouperClientWs.mostRecentRequest.contains("abc"));
17518 assertTrue(GrouperClientWs.mostRecentRequest,
17519 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17520 assertTrue(GrouperClientWs.mostRecentRequest,
17521 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17522 assertTrue(GrouperClientWs.mostRecentRequest,
17523 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17524 assertTrue(GrouperClientWs.mostRecentRequest,
17525 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17526 assertTrue(GrouperClientWs.mostRecentRequest,
17527 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17528
17529
17530
17531
17532 baos = new ByteArrayOutputStream();
17533 System.setOut(new PrintStream(baos));
17534
17535 GrouperClient.main(GrouperClientUtils.splitTrim(
17536 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --paramName0=a --paramValue0=b",
17537 " "));
17538
17539 System.out.flush();
17540 output = new String(baos.toByteArray());
17541
17542 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17543
17544 System.setOut(systemOut);
17545
17546
17547 assertEquals(1, outputLines.length);
17548 outputLine = outputLines[0];
17549
17550 matcher = pattern.matcher(outputLines[0]);
17551
17552 assertTrue(outputLine, matcher.matches());
17553 assertEquals(outputLine, "0", matcher.group(1));
17554 assertEquals(outputLine, "role", matcher.group(2));
17555 assertEquals(outputLine, "aStem:role", matcher.group(3));
17556 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17557 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17558 assertEquals(outputLine, "action", matcher.group(6));
17559 assertEquals(outputLine, "T", matcher.group(7));
17560 assertEquals(outputLine, "T", matcher.group(8));
17561
17562
17563 assertTrue(GrouperClientWs.mostRecentRequest,
17564 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17565 assertTrue(GrouperClientWs.mostRecentRequest,
17566 !GrouperClientWs.mostRecentRequest.contains("actions"));
17567 assertTrue(GrouperClientWs.mostRecentRequest,
17568 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17569 assertTrue(GrouperClientWs.mostRecentRequest,
17570 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17571 assertTrue(GrouperClientWs.mostRecentRequest,
17572 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17573 assertTrue(GrouperClientWs.mostRecentRequest,
17574 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17575 assertTrue(GrouperClientWs.mostRecentRequest,
17576 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17577 assertTrue(GrouperClientWs.mostRecentResponse,
17578 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17579 assertTrue(GrouperClientWs.mostRecentRequest,
17580 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17581 assertTrue(GrouperClientWs.mostRecentRequest,
17582 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17583 assertTrue(GrouperClientWs.mostRecentRequest,
17584 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17585 assertTrue(GrouperClientWs.mostRecentRequest,
17586 GrouperClientWs.mostRecentRequest.contains("params"));
17587 assertTrue(GrouperClientWs.mostRecentRequest,
17588 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17589 assertTrue(GrouperClientWs.mostRecentRequest,
17590 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17591 assertTrue(GrouperClientWs.mostRecentRequest,
17592 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17593 assertTrue(GrouperClientWs.mostRecentRequest,
17594 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17595 assertTrue(GrouperClientWs.mostRecentRequest,
17596 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17597 assertTrue(GrouperClientWs.mostRecentRequest,
17598 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17599
17600
17601
17602
17603 baos = new ByteArrayOutputStream();
17604 System.setOut(new PrintStream(baos));
17605
17606 GrouperClient.main(GrouperClientUtils.splitTrim(
17607 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --outputTemplate=${wsPermissionAssign.permissionType}$newline$",
17608 " "));
17609
17610 System.out.flush();
17611 output = new String(baos.toByteArray());
17612
17613 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17614
17615 System.setOut(systemOut);
17616
17617
17618 assertEquals(1, outputLines.length);
17619 outputLine = outputLines[0].trim();
17620
17621 assertEquals(outputLine, "role", outputLine);
17622
17623
17624 assertTrue(GrouperClientWs.mostRecentRequest,
17625 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17626 assertTrue(GrouperClientWs.mostRecentRequest,
17627 !GrouperClientWs.mostRecentRequest.contains("actions"));
17628 assertTrue(GrouperClientWs.mostRecentRequest,
17629 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17630 assertTrue(GrouperClientWs.mostRecentRequest,
17631 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17632 assertTrue(GrouperClientWs.mostRecentRequest,
17633 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17634 assertTrue(GrouperClientWs.mostRecentRequest,
17635 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17636 assertTrue(GrouperClientWs.mostRecentRequest,
17637 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17638 assertTrue(GrouperClientWs.mostRecentResponse,
17639 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17640 assertTrue(GrouperClientWs.mostRecentRequest,
17641 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17642 assertTrue(GrouperClientWs.mostRecentRequest,
17643 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17644 assertTrue(GrouperClientWs.mostRecentRequest,
17645 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17646 assertTrue(GrouperClientWs.mostRecentRequest,
17647 !GrouperClientWs.mostRecentRequest.contains("params"));
17648 assertTrue(GrouperClientWs.mostRecentRequest,
17649 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17650 assertTrue(GrouperClientWs.mostRecentRequest,
17651 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17652 assertTrue(GrouperClientWs.mostRecentRequest,
17653 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17654 assertTrue(GrouperClientWs.mostRecentRequest,
17655 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17656 assertTrue(GrouperClientWs.mostRecentRequest,
17657 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17658 assertTrue(GrouperClientWs.mostRecentRequest,
17659 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17660
17661
17662
17663
17664
17665 baos = new ByteArrayOutputStream();
17666 System.setOut(new PrintStream(baos));
17667
17668 try {
17669 GrouperClient.main(GrouperClientUtils.splitTrim(
17670 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --actAsSubjectId=" + SubjectTestHelper.SUBJ0_ID,
17671 " "));
17672 } catch (Exception e) {
17673 assertTrue(ExceptionUtils.getFullStackTrace(e).contains("GROUP_NOT_FOUND"));
17674 }
17675 System.out.flush();
17676
17677 System.setOut(systemOut);
17678
17679
17680
17681
17682
17683
17684 baos = new ByteArrayOutputStream();
17685 System.setOut(new PrintStream(baos));
17686
17687 GrouperClient.main(GrouperClientUtils.splitTrim(
17688 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --immediateOnly=T",
17689 " "));
17690
17691 System.out.flush();
17692 output = new String(baos.toByteArray());
17693
17694 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17695
17696 System.setOut(systemOut);
17697
17698
17699 assertEquals(0, GrouperUtil.length(outputLines));
17700
17701
17702 assertTrue(GrouperClientWs.mostRecentRequest,
17703 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17704 assertTrue(GrouperClientWs.mostRecentRequest,
17705 !GrouperClientWs.mostRecentRequest.contains("actions"));
17706 assertTrue(GrouperClientWs.mostRecentRequest,
17707 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17708 assertTrue(GrouperClientWs.mostRecentRequest,
17709 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17710 assertTrue(GrouperClientWs.mostRecentRequest,
17711 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17712 assertTrue(GrouperClientWs.mostRecentRequest,
17713 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17714 assertTrue(GrouperClientWs.mostRecentRequest,
17715 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17716 assertTrue(GrouperClientWs.mostRecentResponse,
17717 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17718 assertTrue(GrouperClientWs.mostRecentRequest,
17719 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17720 assertTrue(GrouperClientWs.mostRecentRequest,
17721 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17722 assertTrue(GrouperClientWs.mostRecentRequest,
17723 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17724 assertTrue(GrouperClientWs.mostRecentRequest,
17725 !GrouperClientWs.mostRecentRequest.contains("params"));
17726 assertTrue(GrouperClientWs.mostRecentRequest,
17727 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17728 assertTrue(GrouperClientWs.mostRecentRequest,
17729 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17730 assertTrue(GrouperClientWs.mostRecentRequest,
17731 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17732 assertTrue(GrouperClientWs.mostRecentRequest,
17733 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17734 assertTrue(GrouperClientWs.mostRecentRequest,
17735 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17736 assertTrue(GrouperClientWs.mostRecentRequest,
17737 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17738 assertTrue(GrouperClientWs.mostRecentRequest,
17739 GrouperClientWs.mostRecentRequest.contains("<immediateOnly>T</immediateOnly>"));
17740
17741
17742
17743
17744 baos = new ByteArrayOutputStream();
17745 System.setOut(new PrintStream(baos));
17746
17747 GrouperClient.main(GrouperClientUtils.splitTrim(
17748 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --permissionType=role_subject",
17749 " "));
17750
17751 System.out.flush();
17752 output = new String(baos.toByteArray());
17753
17754 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17755
17756 System.setOut(systemOut);
17757
17758
17759 assertEquals(1, GrouperUtil.length(outputLines));
17760
17761
17762 assertTrue(GrouperClientWs.mostRecentRequest,
17763 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17764 assertTrue(GrouperClientWs.mostRecentRequest,
17765 !GrouperClientWs.mostRecentRequest.contains("actions"));
17766 assertTrue(GrouperClientWs.mostRecentRequest,
17767 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17768 assertTrue(GrouperClientWs.mostRecentRequest,
17769 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17770 assertTrue(GrouperClientWs.mostRecentRequest,
17771 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17772 assertTrue(GrouperClientWs.mostRecentRequest,
17773 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17774 assertTrue(GrouperClientWs.mostRecentRequest,
17775 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17776 assertTrue(GrouperClientWs.mostRecentResponse,
17777 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17778 assertTrue(GrouperClientWs.mostRecentRequest,
17779 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17780 assertTrue(GrouperClientWs.mostRecentRequest,
17781 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17782 assertTrue(GrouperClientWs.mostRecentRequest,
17783 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17784 assertTrue(GrouperClientWs.mostRecentRequest,
17785 !GrouperClientWs.mostRecentRequest.contains("params"));
17786 assertTrue(GrouperClientWs.mostRecentRequest,
17787 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17788 assertTrue(GrouperClientWs.mostRecentRequest,
17789 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17790 assertTrue(GrouperClientWs.mostRecentRequest,
17791 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17792 assertTrue(GrouperClientWs.mostRecentRequest,
17793 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17794 assertTrue(GrouperClientWs.mostRecentRequest,
17795 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17796 assertTrue(GrouperClientWs.mostRecentRequest,
17797 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17798 assertTrue(GrouperClientWs.mostRecentRequest,
17799 !GrouperClientWs.mostRecentRequest.contains("<immediateOnly>T</immediateOnly>"));
17800 assertTrue(GrouperClientWs.mostRecentRequest,
17801 GrouperClientWs.mostRecentRequest.contains("<permissionType>role_subject</permissionType>"));
17802 assertTrue(GrouperClientWs.mostRecentRequest,
17803 !GrouperClientWs.mostRecentRequest.contains("<permissionProcessor>role_subject</permissionProcessor>"));
17804
17805
17806
17807
17808 baos = new ByteArrayOutputStream();
17809 System.setOut(new PrintStream(baos));
17810
17811 GrouperClient.main(GrouperClientUtils.splitTrim(
17812 "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --permissionProcessor=FILTER_REDUNDANT_PERMISSIONS",
17813 " "));
17814
17815 System.out.flush();
17816 output = new String(baos.toByteArray());
17817
17818 outputLines = GrouperClientUtils.splitTrim(output, "\n");
17819
17820 System.setOut(systemOut);
17821
17822
17823 assertEquals(1, GrouperUtil.length(outputLines));
17824
17825
17826 assertTrue(GrouperClientWs.mostRecentRequest,
17827 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17828 assertTrue(GrouperClientWs.mostRecentRequest,
17829 !GrouperClientWs.mostRecentRequest.contains("actions"));
17830 assertTrue(GrouperClientWs.mostRecentRequest,
17831 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17832 assertTrue(GrouperClientWs.mostRecentRequest,
17833 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17834 assertTrue(GrouperClientWs.mostRecentRequest,
17835 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17836 assertTrue(GrouperClientWs.mostRecentRequest,
17837 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17838 assertTrue(GrouperClientWs.mostRecentRequest,
17839 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17840 assertTrue(GrouperClientWs.mostRecentResponse,
17841 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17842 assertTrue(GrouperClientWs.mostRecentRequest,
17843 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17844 assertTrue(GrouperClientWs.mostRecentRequest,
17845 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17846 assertTrue(GrouperClientWs.mostRecentRequest,
17847 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17848 assertTrue(GrouperClientWs.mostRecentRequest,
17849 !GrouperClientWs.mostRecentRequest.contains("params"));
17850 assertTrue(GrouperClientWs.mostRecentRequest,
17851 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17852 assertTrue(GrouperClientWs.mostRecentRequest,
17853 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17854 assertTrue(GrouperClientWs.mostRecentRequest,
17855 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17856 assertTrue(GrouperClientWs.mostRecentRequest,
17857 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17858 assertTrue(GrouperClientWs.mostRecentRequest,
17859 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17860 assertTrue(GrouperClientWs.mostRecentRequest,
17861 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17862 assertTrue(GrouperClientWs.mostRecentRequest,
17863 !GrouperClientWs.mostRecentRequest.contains("<immediateOnly>T</immediateOnly>"));
17864 assertTrue(GrouperClientWs.mostRecentRequest,
17865 !GrouperClientWs.mostRecentRequest.contains("<permissionType>role_subject</permissionType>"));
17866 assertTrue(GrouperClientWs.mostRecentRequest,
17867 GrouperClientWs.mostRecentRequest.contains("<permissionProcessor>FILTER_REDUNDANT_PERMISSIONS</permissionProcessor>"));
17868
17869 } finally {
17870 System.setOut(systemOut);
17871 }
17872
17873 }
17874
17875
17876
17877
17878 public void testGetPermissionAssignsPIT() throws Exception {
17879
17880 GrouperSession grouperSession = GrouperSession.startRootSession();
17881
17882 Stem aStem = Stem.saveStem(grouperSession, "aStem", null,"aStem", "a stem", "a stem description", null, false);
17883
17884
17885 Role role = aStem.addChildRole("role", "role");
17886 Role role2 = aStem.addChildRole("role2", "role2");
17887
17888 ((Group)role).addMember(SubjectTestHelper.SUBJ0);
17889 ((Group)role2).addMember(SubjectTestHelper.SUBJ1);
17890
17891 AttributeDef permissionDef = aStem.addChildAttributeDef("permissionDef", AttributeDefType.perm);
17892 permissionDef.setAssignToEffMembership(true);
17893 permissionDef.setAssignToGroup(true);
17894 permissionDef.store();
17895 AttributeDefName permissionDefName = aStem.addChildAttributeDefName(permissionDef, "permissionDefName", "permissionDefName");
17896 AttributeDefName permissionDefName2 = aStem.addChildAttributeDefName(permissionDef, "permissionDefName2", "permissionDefName2");
17897
17898 permissionDef.getAttributeDefActionDelegate().addAction("action");
17899 permissionDef.getAttributeDefActionDelegate().addAction("action2");
17900
17901 Thread.sleep(100);
17902 Timestamp before = new Timestamp(new Date().getTime());
17903 Thread.sleep(100);
17904
17905
17906
17907
17908 AttributeAssignResult result1 = role.getPermissionRoleDelegate().assignRolePermission("action", permissionDefName);
17909 AttributeAssignResult result2 = role2.getPermissionRoleDelegate()
17910 .assignSubjectRolePermission("action2", permissionDefName2, SubjectTestHelper.SUBJ1);
17911 ChangeLogTempToEntity.convertRecords();
17912
17913 Thread.sleep(100);
17914 Timestamp pointInTime = new Timestamp(new Date().getTime());
17915 Thread.sleep(100);
17916
17917
17918 result1.getAttributeAssign().delete();
17919 result2.getAttributeAssign().delete();
17920 ChangeLogTempToEntity.convertRecords();
17921
17922 Thread.sleep(100);
17923 Timestamp after = new Timestamp(new Date().getTime());
17924 Thread.sleep(100);
17925
17926 PrintStream systemOut = System.out;
17927
17928 ByteArrayOutputStream baos = new ByteArrayOutputStream();
17929 System.setOut(new PrintStream(baos));
17930
17931 try {
17932
17933 ArrayList<String> args = new ArrayList<String>();
17934 args.add("--operation=getPermissionAssignmentsWs");
17935 args.add("--attributeDefNames=aStem:permissionDef");
17936 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
17937 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
17938 GrouperClient.main(args.toArray(new String[0]));
17939
17940 System.out.flush();
17941 String output = new String(baos.toByteArray());
17942
17943 System.setOut(systemOut);
17944
17945 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
17946
17947
17948
17949
17950 Pattern pattern = Pattern
17951 .compile("^Index: (\\d+)\\: permissionType\\: (.+), role\\: (.+), subject\\: (.+), attributeDefNameName: (.+), action\\: (.+), allowedOverall\\: (T|F), enabled\\:.*$");
17952
17953 assertEquals(2, outputLines.length);
17954 String outputLine = outputLines[0];
17955
17956 Matcher matcher = pattern.matcher(outputLines[0]);
17957
17958 assertTrue(outputLine, matcher.matches());
17959 assertEquals(outputLine, "0", matcher.group(1));
17960 assertEquals(outputLine, "role", matcher.group(2));
17961 assertEquals(outputLine, "aStem:role", matcher.group(3));
17962 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17963 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17964 assertEquals(outputLine, "action", matcher.group(6));
17965
17966 outputLine = outputLines[1];
17967
17968 matcher = pattern.matcher(outputLines[1]);
17969
17970 assertTrue(outputLine, matcher.matches());
17971 assertEquals(outputLine, "1", matcher.group(1));
17972 assertEquals(outputLine, "role_subject", matcher.group(2));
17973 assertEquals(outputLine, "aStem:role2", matcher.group(3));
17974 assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
17975 assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
17976 assertEquals(outputLine, "action2", matcher.group(6));
17977
17978 assertTrue(GrouperClientWs.mostRecentRequest,
17979 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17980 assertTrue(GrouperClientWs.mostRecentRequest,
17981 !GrouperClientWs.mostRecentRequest.contains("actions"));
17982 assertTrue(GrouperClientWs.mostRecentRequest,
17983 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17984 assertTrue(GrouperClientWs.mostRecentRequest,
17985 !GrouperClientWs.mostRecentRequest.contains("enabled"));
17986 assertTrue(GrouperClientWs.mostRecentRequest,
17987 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17988 assertTrue(GrouperClientWs.mostRecentRequest,
17989 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17990 assertTrue(GrouperClientWs.mostRecentRequest,
17991 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17992 assertTrue(GrouperClientWs.mostRecentRequest,
17993 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17994 assertTrue(GrouperClientWs.mostRecentRequest,
17995 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17996 assertTrue(GrouperClientWs.mostRecentRequest,
17997 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17998 assertTrue(GrouperClientWs.mostRecentRequest,
17999 !GrouperClientWs.mostRecentRequest.contains("params"));
18000 assertTrue(GrouperClientWs.mostRecentRequest,
18001 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18002 assertTrue(GrouperClientWs.mostRecentRequest,
18003 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18004 assertTrue(GrouperClientWs.mostRecentRequest,
18005 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
18006 assertTrue(GrouperClientWs.mostRecentRequest,
18007 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18008 assertTrue(GrouperClientWs.mostRecentRequest,
18009 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18010 assertTrue(GrouperClientWs.mostRecentRequest,
18011 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18012
18013
18014
18015
18016
18017
18018
18019 baos = new ByteArrayOutputStream();
18020 System.setOut(new PrintStream(baos));
18021
18022 args = new ArrayList<String>();
18023 args.add("--operation=getPermissionAssignmentsWs");
18024 args.add("--attributeDefUuids=" + permissionDef.getId());
18025 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18026 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18027 GrouperClient.main(args.toArray(new String[0]));
18028
18029 System.out.flush();
18030 output = new String(baos.toByteArray());
18031
18032 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18033
18034 System.setOut(systemOut);
18035
18036
18037 assertEquals(2, outputLines.length);
18038 outputLine = outputLines[0];
18039
18040 matcher = pattern.matcher(outputLines[0]);
18041
18042 assertTrue(outputLine, matcher.matches());
18043 assertEquals(outputLine, "0", matcher.group(1));
18044 assertEquals(outputLine, "role", matcher.group(2));
18045 assertEquals(outputLine, "aStem:role", matcher.group(3));
18046 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18047 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18048 assertEquals(outputLine, "action", matcher.group(6));
18049
18050 outputLine = outputLines[1];
18051
18052 matcher = pattern.matcher(outputLines[1]);
18053
18054 assertTrue(outputLine, matcher.matches());
18055 assertEquals(outputLine, "1", matcher.group(1));
18056 assertEquals(outputLine, "role_subject", matcher.group(2));
18057 assertEquals(outputLine, "aStem:role2", matcher.group(3));
18058 assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
18059 assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
18060 assertEquals(outputLine, "action2", matcher.group(6));
18061
18062 assertTrue(GrouperClientWs.mostRecentRequest,
18063 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18064 assertTrue(GrouperClientWs.mostRecentRequest,
18065 !GrouperClientWs.mostRecentRequest.contains("actions"));
18066 assertTrue(GrouperClientWs.mostRecentRequest,
18067 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18068 assertTrue(GrouperClientWs.mostRecentRequest,
18069 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18070 assertTrue(GrouperClientWs.mostRecentRequest,
18071 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18072 assertTrue(GrouperClientWs.mostRecentRequest,
18073 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18074 assertTrue(GrouperClientWs.mostRecentRequest,
18075 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18076 assertTrue(GrouperClientWs.mostRecentRequest,
18077 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18078 assertTrue(GrouperClientWs.mostRecentRequest,
18079 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18080 assertTrue(GrouperClientWs.mostRecentRequest,
18081 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18082 assertTrue(GrouperClientWs.mostRecentRequest,
18083 !GrouperClientWs.mostRecentRequest.contains("params"));
18084 assertTrue(GrouperClientWs.mostRecentRequest,
18085 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18086 assertTrue(GrouperClientWs.mostRecentRequest,
18087 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18088 assertTrue(GrouperClientWs.mostRecentRequest,
18089 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
18090 assertTrue(GrouperClientWs.mostRecentRequest,
18091 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18092 assertTrue(GrouperClientWs.mostRecentRequest,
18093 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18094 assertTrue(GrouperClientWs.mostRecentRequest,
18095 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18096
18097
18098
18099
18100
18101
18102 baos = new ByteArrayOutputStream();
18103 System.setOut(new PrintStream(baos));
18104
18105 args = new ArrayList<String>();
18106 args.add("--operation=getPermissionAssignmentsWs");
18107 args.add("--attributeDefNameNames=" + permissionDefName.getName());
18108 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18109 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18110 GrouperClient.main(args.toArray(new String[0]));
18111
18112 System.out.flush();
18113 output = new String(baos.toByteArray());
18114
18115 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18116
18117 System.setOut(systemOut);
18118
18119
18120 assertEquals(1, outputLines.length);
18121 outputLine = outputLines[0];
18122
18123 matcher = pattern.matcher(outputLines[0]);
18124
18125 assertTrue(outputLine, matcher.matches());
18126 assertEquals(outputLine, "0", matcher.group(1));
18127 assertEquals(outputLine, "role", matcher.group(2));
18128 assertEquals(outputLine, "aStem:role", matcher.group(3));
18129 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18130 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18131 assertEquals(outputLine, "action", matcher.group(6));
18132
18133 assertTrue(GrouperClientWs.mostRecentRequest,
18134 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18135 assertTrue(GrouperClientWs.mostRecentRequest,
18136 !GrouperClientWs.mostRecentRequest.contains("actions"));
18137 assertTrue(GrouperClientWs.mostRecentRequest,
18138 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18139 assertTrue(GrouperClientWs.mostRecentRequest,
18140 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18141 assertTrue(GrouperClientWs.mostRecentRequest,
18142 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18143 assertTrue(GrouperClientWs.mostRecentRequest,
18144 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18145 assertTrue(GrouperClientWs.mostRecentRequest,
18146 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18147 assertTrue(GrouperClientWs.mostRecentRequest,
18148 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18149 assertTrue(GrouperClientWs.mostRecentRequest,
18150 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18151 assertTrue(GrouperClientWs.mostRecentRequest,
18152 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18153 assertTrue(GrouperClientWs.mostRecentRequest,
18154 !GrouperClientWs.mostRecentRequest.contains("params"));
18155 assertTrue(GrouperClientWs.mostRecentRequest,
18156 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18157 assertTrue(GrouperClientWs.mostRecentRequest,
18158 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18159 assertTrue(GrouperClientWs.mostRecentRequest,
18160 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18161 assertTrue(GrouperClientWs.mostRecentRequest,
18162 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
18163 assertTrue(GrouperClientWs.mostRecentRequest,
18164 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18165 assertTrue(GrouperClientWs.mostRecentRequest,
18166 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18167
18168
18169
18170
18171
18172 baos = new ByteArrayOutputStream();
18173 System.setOut(new PrintStream(baos));
18174
18175 args = new ArrayList<String>();
18176 args.add("--operation=getPermissionAssignmentsWs");
18177 args.add("--attributeDefNameUuids=" + permissionDefName.getId());
18178 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18179 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18180 GrouperClient.main(args.toArray(new String[0]));
18181
18182 System.out.flush();
18183 output = new String(baos.toByteArray());
18184
18185 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18186
18187 System.setOut(systemOut);
18188
18189
18190 assertEquals(1, outputLines.length);
18191 outputLine = outputLines[0];
18192
18193 matcher = pattern.matcher(outputLines[0]);
18194
18195 assertTrue(outputLine, matcher.matches());
18196 assertEquals(outputLine, "0", matcher.group(1));
18197 assertEquals(outputLine, "role", matcher.group(2));
18198 assertEquals(outputLine, "aStem:role", matcher.group(3));
18199 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18200 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18201 assertEquals(outputLine, "action", matcher.group(6));
18202
18203 assertTrue(GrouperClientWs.mostRecentRequest,
18204 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18205 assertTrue(GrouperClientWs.mostRecentRequest,
18206 !GrouperClientWs.mostRecentRequest.contains("actions"));
18207 assertTrue(GrouperClientWs.mostRecentRequest,
18208 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18209 assertTrue(GrouperClientWs.mostRecentRequest,
18210 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18211 assertTrue(GrouperClientWs.mostRecentRequest,
18212 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18213 assertTrue(GrouperClientWs.mostRecentRequest,
18214 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18215 assertTrue(GrouperClientWs.mostRecentRequest,
18216 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18217 assertTrue(GrouperClientWs.mostRecentRequest,
18218 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18219 assertTrue(GrouperClientWs.mostRecentRequest,
18220 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18221 assertTrue(GrouperClientWs.mostRecentRequest,
18222 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18223 assertTrue(GrouperClientWs.mostRecentRequest,
18224 !GrouperClientWs.mostRecentRequest.contains("params"));
18225 assertTrue(GrouperClientWs.mostRecentRequest,
18226 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18227 assertTrue(GrouperClientWs.mostRecentRequest,
18228 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18229 assertTrue(GrouperClientWs.mostRecentRequest,
18230 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18231 assertTrue(GrouperClientWs.mostRecentRequest,
18232 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
18233 assertTrue(GrouperClientWs.mostRecentRequest,
18234 !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18235 assertTrue(GrouperClientWs.mostRecentRequest,
18236 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18237
18238
18239
18240
18241
18242 baos = new ByteArrayOutputStream();
18243 System.setOut(new PrintStream(baos));
18244
18245 args = new ArrayList<String>();
18246 args.add("--operation=getPermissionAssignmentsWs");
18247 args.add("--roleNames=" + role.getName());
18248 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18249 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18250 GrouperClient.main(args.toArray(new String[0]));
18251
18252 System.out.flush();
18253 output = new String(baos.toByteArray());
18254
18255 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18256
18257 System.setOut(systemOut);
18258
18259
18260 assertEquals(1, outputLines.length);
18261 outputLine = outputLines[0];
18262
18263 matcher = pattern.matcher(outputLines[0]);
18264
18265 assertTrue(outputLine, matcher.matches());
18266 assertEquals(outputLine, "0", matcher.group(1));
18267 assertEquals(outputLine, "role", matcher.group(2));
18268 assertEquals(outputLine, "aStem:role", matcher.group(3));
18269 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18270 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18271 assertEquals(outputLine, "action", matcher.group(6));
18272
18273 assertTrue(GrouperClientWs.mostRecentRequest,
18274 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18275 assertTrue(GrouperClientWs.mostRecentRequest,
18276 !GrouperClientWs.mostRecentRequest.contains("actions"));
18277 assertTrue(GrouperClientWs.mostRecentRequest,
18278 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18279 assertTrue(GrouperClientWs.mostRecentRequest,
18280 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18281 assertTrue(GrouperClientWs.mostRecentRequest,
18282 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18283 assertTrue(GrouperClientWs.mostRecentRequest,
18284 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18285 assertTrue(GrouperClientWs.mostRecentRequest,
18286 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18287 assertTrue(GrouperClientWs.mostRecentRequest,
18288 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18289 assertTrue(GrouperClientWs.mostRecentRequest,
18290 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18291 assertTrue(GrouperClientWs.mostRecentRequest,
18292 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18293 assertTrue(GrouperClientWs.mostRecentRequest,
18294 !GrouperClientWs.mostRecentRequest.contains("params"));
18295 assertTrue(GrouperClientWs.mostRecentRequest,
18296 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18297 assertTrue(GrouperClientWs.mostRecentRequest,
18298 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18299 assertTrue(GrouperClientWs.mostRecentRequest,
18300 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18301 assertTrue(GrouperClientWs.mostRecentRequest,
18302 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18303 assertTrue(GrouperClientWs.mostRecentRequest,
18304 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18305 assertTrue(GrouperClientWs.mostRecentRequest,
18306 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18307
18308
18309
18310
18311
18312 baos = new ByteArrayOutputStream();
18313 System.setOut(new PrintStream(baos));
18314
18315 args = new ArrayList<String>();
18316 args.add("--operation=getPermissionAssignmentsWs");
18317 args.add("--roleUuids=" + role.getId());
18318 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18319 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18320 GrouperClient.main(args.toArray(new String[0]));
18321
18322 System.out.flush();
18323 output = new String(baos.toByteArray());
18324
18325 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18326
18327 System.setOut(systemOut);
18328
18329
18330 assertEquals(1, outputLines.length);
18331 outputLine = outputLines[0];
18332
18333 matcher = pattern.matcher(outputLines[0]);
18334
18335 assertTrue(outputLine, matcher.matches());
18336 assertEquals(outputLine, "0", matcher.group(1));
18337 assertEquals(outputLine, "role", matcher.group(2));
18338 assertEquals(outputLine, "aStem:role", matcher.group(3));
18339 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18340 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18341 assertEquals(outputLine, "action", matcher.group(6));
18342
18343 assertTrue(GrouperClientWs.mostRecentRequest,
18344 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18345 assertTrue(GrouperClientWs.mostRecentRequest,
18346 !GrouperClientWs.mostRecentRequest.contains("actions"));
18347 assertTrue(GrouperClientWs.mostRecentRequest,
18348 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18349 assertTrue(GrouperClientWs.mostRecentRequest,
18350 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18351 assertTrue(GrouperClientWs.mostRecentRequest,
18352 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18353 assertTrue(GrouperClientWs.mostRecentRequest,
18354 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18355 assertTrue(GrouperClientWs.mostRecentRequest,
18356 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18357 assertTrue(GrouperClientWs.mostRecentRequest,
18358 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18359 assertTrue(GrouperClientWs.mostRecentRequest,
18360 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18361 assertTrue(GrouperClientWs.mostRecentRequest,
18362 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18363 assertTrue(GrouperClientWs.mostRecentRequest,
18364 !GrouperClientWs.mostRecentRequest.contains("params"));
18365 assertTrue(GrouperClientWs.mostRecentRequest,
18366 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18367 assertTrue(GrouperClientWs.mostRecentRequest,
18368 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18369 assertTrue(GrouperClientWs.mostRecentRequest,
18370 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18371 assertTrue(GrouperClientWs.mostRecentRequest,
18372 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18373 assertTrue(GrouperClientWs.mostRecentRequest,
18374 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
18375 assertTrue(GrouperClientWs.mostRecentRequest,
18376 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18377
18378
18379
18380
18381 baos = new ByteArrayOutputStream();
18382 System.setOut(new PrintStream(baos));
18383
18384 args = new ArrayList<String>();
18385 args.add("--operation=getPermissionAssignmentsWs");
18386 args.add("--roleNames=" + role.getName());
18387 args.add("--actions=a");
18388 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18389 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18390 GrouperClient.main(args.toArray(new String[0]));
18391
18392 System.out.flush();
18393 output = new String(baos.toByteArray());
18394
18395 System.setOut(systemOut);
18396
18397 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18398
18399 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
18400
18401
18402 assertTrue(GrouperClientWs.mostRecentRequest,
18403 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18404 assertTrue(GrouperClientWs.mostRecentRequest,
18405 GrouperClientWs.mostRecentRequest.contains("actions"));
18406 assertTrue(GrouperClientWs.mostRecentRequest,
18407 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18408 assertTrue(GrouperClientWs.mostRecentRequest,
18409 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18410 assertTrue(GrouperClientWs.mostRecentRequest,
18411 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18412 assertTrue(GrouperClientWs.mostRecentRequest,
18413 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18414 assertTrue(GrouperClientWs.mostRecentRequest,
18415 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18416 assertTrue(GrouperClientWs.mostRecentRequest,
18417 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18418 assertTrue(GrouperClientWs.mostRecentRequest,
18419 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18420 assertTrue(GrouperClientWs.mostRecentRequest,
18421 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18422 assertTrue(GrouperClientWs.mostRecentRequest,
18423 !GrouperClientWs.mostRecentRequest.contains("params"));
18424 assertTrue(GrouperClientWs.mostRecentRequest,
18425 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18426 assertTrue(GrouperClientWs.mostRecentRequest,
18427 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18428 assertTrue(GrouperClientWs.mostRecentRequest,
18429 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18430 assertTrue(GrouperClientWs.mostRecentRequest,
18431 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18432 assertTrue(GrouperClientWs.mostRecentRequest,
18433 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18434 assertTrue(GrouperClientWs.mostRecentRequest,
18435 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18436
18437
18438
18439
18440 baos = new ByteArrayOutputStream();
18441 System.setOut(new PrintStream(baos));
18442
18443 args = new ArrayList<String>();
18444 args.add("--operation=getPermissionAssignmentsWs");
18445 args.add("--roleNames=" + role.getName());
18446 args.add("--includeAttributeAssignments=T");
18447 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18448 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18449 GrouperClient.main(args.toArray(new String[0]));
18450
18451 System.out.flush();
18452 output = new String(baos.toByteArray());
18453
18454 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18455
18456 System.setOut(systemOut);
18457
18458
18459 assertEquals(1, outputLines.length);
18460 outputLine = outputLines[0];
18461
18462 matcher = pattern.matcher(outputLines[0]);
18463
18464 assertTrue(outputLine, matcher.matches());
18465 assertEquals(outputLine, "0", matcher.group(1));
18466 assertEquals(outputLine, "role", matcher.group(2));
18467 assertEquals(outputLine, "aStem:role", matcher.group(3));
18468 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18469 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18470 assertEquals(outputLine, "action", matcher.group(6));
18471
18472
18473 assertTrue(GrouperClientWs.mostRecentRequest,
18474 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18475 assertTrue(GrouperClientWs.mostRecentRequest,
18476 !GrouperClientWs.mostRecentRequest.contains("actions"));
18477 assertTrue(GrouperClientWs.mostRecentRequest,
18478 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18479 assertTrue(GrouperClientWs.mostRecentRequest,
18480 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18481 assertTrue(GrouperClientWs.mostRecentRequest,
18482 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18483 assertTrue(GrouperClientWs.mostRecentRequest,
18484 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18485 assertTrue(GrouperClientWs.mostRecentRequest,
18486 GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18487 assertTrue(GrouperClientWs.mostRecentResponse,
18488 GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
18489 assertTrue(GrouperClientWs.mostRecentRequest,
18490 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18491 assertTrue(GrouperClientWs.mostRecentRequest,
18492 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18493 assertTrue(GrouperClientWs.mostRecentRequest,
18494 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18495 assertTrue(GrouperClientWs.mostRecentRequest,
18496 !GrouperClientWs.mostRecentRequest.contains("params"));
18497 assertTrue(GrouperClientWs.mostRecentRequest,
18498 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18499 assertTrue(GrouperClientWs.mostRecentRequest,
18500 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18501 assertTrue(GrouperClientWs.mostRecentRequest,
18502 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18503 assertTrue(GrouperClientWs.mostRecentRequest,
18504 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18505 assertTrue(GrouperClientWs.mostRecentRequest,
18506 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18507 assertTrue(GrouperClientWs.mostRecentRequest,
18508 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18509
18510
18511
18512
18513 baos = new ByteArrayOutputStream();
18514 System.setOut(new PrintStream(baos));
18515
18516 args = new ArrayList<String>();
18517 args.add("--operation=getPermissionAssignmentsWs");
18518 args.add("--roleNames=" + role.getName());
18519 args.add("--includeAttributeAssignments=T");
18520 args.add("--includeAssignmentsOnAssignments=T");
18521 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18522 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18523 GrouperClient.main(args.toArray(new String[0]));
18524
18525 System.out.flush();
18526 output = new String(baos.toByteArray());
18527
18528 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18529
18530 System.setOut(systemOut);
18531
18532
18533 assertEquals(1, outputLines.length);
18534 outputLine = outputLines[0];
18535
18536 matcher = pattern.matcher(outputLines[0]);
18537
18538 assertTrue(outputLine, matcher.matches());
18539 assertEquals(outputLine, "0", matcher.group(1));
18540 assertEquals(outputLine, "role", matcher.group(2));
18541 assertEquals(outputLine, "aStem:role", matcher.group(3));
18542 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18543 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18544 assertEquals(outputLine, "action", matcher.group(6));
18545
18546
18547 assertTrue(GrouperClientWs.mostRecentRequest,
18548 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18549 assertTrue(GrouperClientWs.mostRecentRequest,
18550 !GrouperClientWs.mostRecentRequest.contains("actions"));
18551 assertTrue(GrouperClientWs.mostRecentRequest,
18552 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18553 assertTrue(GrouperClientWs.mostRecentRequest,
18554 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18555 assertTrue(GrouperClientWs.mostRecentRequest,
18556 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18557 assertTrue(GrouperClientWs.mostRecentRequest,
18558 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18559 assertTrue(GrouperClientWs.mostRecentRequest,
18560 GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18561 assertTrue(GrouperClientWs.mostRecentResponse,
18562 GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
18563 assertTrue(GrouperClientWs.mostRecentRequest,
18564 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18565 assertTrue(GrouperClientWs.mostRecentRequest,
18566 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18567 assertTrue(GrouperClientWs.mostRecentRequest,
18568 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18569 assertTrue(GrouperClientWs.mostRecentRequest,
18570 !GrouperClientWs.mostRecentRequest.contains("params"));
18571 assertTrue(GrouperClientWs.mostRecentRequest,
18572 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18573 assertTrue(GrouperClientWs.mostRecentRequest,
18574 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18575 assertTrue(GrouperClientWs.mostRecentRequest,
18576 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18577 assertTrue(GrouperClientWs.mostRecentRequest,
18578 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18579 assertTrue(GrouperClientWs.mostRecentRequest,
18580 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18581 assertTrue(GrouperClientWs.mostRecentRequest,
18582 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18583 assertTrue(GrouperClientWs.mostRecentResponse,
18584 !GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
18585
18586
18587
18588
18589 baos = new ByteArrayOutputStream();
18590 System.setOut(new PrintStream(baos));
18591
18592 args = new ArrayList<String>();
18593 args.add("--operation=getPermissionAssignmentsWs");
18594 args.add("--roleNames=" + role.getName());
18595 args.add("--includePermissionAssignDetail=T");
18596 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18597 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18598 GrouperClient.main(args.toArray(new String[0]));
18599
18600 System.out.flush();
18601 output = new String(baos.toByteArray());
18602
18603 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18604
18605 System.setOut(systemOut);
18606
18607
18608 assertEquals(1, outputLines.length);
18609 outputLine = outputLines[0];
18610
18611 matcher = pattern.matcher(outputLines[0]);
18612
18613 assertTrue(outputLine, matcher.matches());
18614 assertEquals(outputLine, "0", matcher.group(1));
18615 assertEquals(outputLine, "role", matcher.group(2));
18616 assertEquals(outputLine, "aStem:role", matcher.group(3));
18617 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18618 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18619 assertEquals(outputLine, "action", matcher.group(6));
18620
18621
18622 assertTrue(GrouperClientWs.mostRecentRequest,
18623 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18624 assertTrue(GrouperClientWs.mostRecentRequest,
18625 !GrouperClientWs.mostRecentRequest.contains("actions"));
18626 assertTrue(GrouperClientWs.mostRecentRequest,
18627 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18628 assertTrue(GrouperClientWs.mostRecentRequest,
18629 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18630 assertTrue(GrouperClientWs.mostRecentRequest,
18631 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18632 assertTrue(GrouperClientWs.mostRecentRequest,
18633 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18634 assertTrue(GrouperClientWs.mostRecentRequest,
18635 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18636 assertTrue(GrouperClientWs.mostRecentResponse,
18637 GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
18638 assertTrue(GrouperClientWs.mostRecentRequest,
18639 GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18640 assertTrue(GrouperClientWs.mostRecentRequest,
18641 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18642 assertTrue(GrouperClientWs.mostRecentRequest,
18643 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18644 assertTrue(GrouperClientWs.mostRecentRequest,
18645 !GrouperClientWs.mostRecentRequest.contains("params"));
18646 assertTrue(GrouperClientWs.mostRecentRequest,
18647 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18648 assertTrue(GrouperClientWs.mostRecentRequest,
18649 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18650 assertTrue(GrouperClientWs.mostRecentRequest,
18651 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18652 assertTrue(GrouperClientWs.mostRecentRequest,
18653 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18654 assertTrue(GrouperClientWs.mostRecentRequest,
18655 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18656 assertTrue(GrouperClientWs.mostRecentRequest,
18657 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18658 assertTrue(GrouperClientWs.mostRecentResponse,
18659 !GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
18660
18661
18662
18663
18664 baos = new ByteArrayOutputStream();
18665 System.setOut(new PrintStream(baos));
18666
18667 args = new ArrayList<String>();
18668 args.add("--operation=getPermissionAssignmentsWs");
18669 args.add("--roleNames=" + role.getName());
18670 args.add("--includeAttributeDefNames=T");
18671 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18672 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18673 GrouperClient.main(args.toArray(new String[0]));
18674
18675 System.out.flush();
18676 output = new String(baos.toByteArray());
18677
18678 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18679
18680 System.setOut(systemOut);
18681
18682
18683 assertEquals(1, outputLines.length);
18684 outputLine = outputLines[0];
18685
18686 matcher = pattern.matcher(outputLines[0]);
18687
18688 assertTrue(outputLine, matcher.matches());
18689 assertEquals(outputLine, "0", matcher.group(1));
18690 assertEquals(outputLine, "role", matcher.group(2));
18691 assertEquals(outputLine, "aStem:role", matcher.group(3));
18692 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18693 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18694 assertEquals(outputLine, "action", matcher.group(6));
18695
18696
18697 assertTrue(GrouperClientWs.mostRecentRequest,
18698 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18699 assertTrue(GrouperClientWs.mostRecentRequest,
18700 !GrouperClientWs.mostRecentRequest.contains("actions"));
18701 assertTrue(GrouperClientWs.mostRecentRequest,
18702 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18703 assertTrue(GrouperClientWs.mostRecentRequest,
18704 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18705 assertTrue(GrouperClientWs.mostRecentRequest,
18706 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18707 assertTrue(GrouperClientWs.mostRecentRequest,
18708 GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18709 assertTrue(GrouperClientWs.mostRecentRequest,
18710 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18711 assertTrue(GrouperClientWs.mostRecentResponse,
18712 GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
18713 assertTrue(GrouperClientWs.mostRecentRequest,
18714 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18715 assertTrue(GrouperClientWs.mostRecentRequest,
18716 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18717 assertTrue(GrouperClientWs.mostRecentRequest,
18718 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18719 assertTrue(GrouperClientWs.mostRecentRequest,
18720 !GrouperClientWs.mostRecentRequest.contains("params"));
18721 assertTrue(GrouperClientWs.mostRecentRequest,
18722 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18723 assertTrue(GrouperClientWs.mostRecentRequest,
18724 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18725 assertTrue(GrouperClientWs.mostRecentRequest,
18726 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18727 assertTrue(GrouperClientWs.mostRecentRequest,
18728 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18729 assertTrue(GrouperClientWs.mostRecentRequest,
18730 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18731 assertTrue(GrouperClientWs.mostRecentRequest,
18732 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18733
18734
18735
18736
18737 baos = new ByteArrayOutputStream();
18738 System.setOut(new PrintStream(baos));
18739
18740 args = new ArrayList<String>();
18741 args.add("--operation=getPermissionAssignmentsWs");
18742 args.add("--roleNames=" + role.getName());
18743 args.add("--includeSubjectDetail=T");
18744 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18745 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18746 GrouperClient.main(args.toArray(new String[0]));
18747
18748 System.out.flush();
18749 output = new String(baos.toByteArray());
18750
18751 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18752
18753 System.setOut(systemOut);
18754
18755
18756 assertEquals(1, outputLines.length);
18757 outputLine = outputLines[0];
18758
18759 matcher = pattern.matcher(outputLines[0]);
18760
18761 assertTrue(outputLine, matcher.matches());
18762 assertEquals(outputLine, "0", matcher.group(1));
18763 assertEquals(outputLine, "role", matcher.group(2));
18764 assertEquals(outputLine, "aStem:role", matcher.group(3));
18765 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18766 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18767 assertEquals(outputLine, "action", matcher.group(6));
18768
18769
18770 assertTrue(GrouperClientWs.mostRecentRequest,
18771 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18772 assertTrue(GrouperClientWs.mostRecentRequest,
18773 !GrouperClientWs.mostRecentRequest.contains("actions"));
18774 assertTrue(GrouperClientWs.mostRecentRequest,
18775 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18776 assertTrue(GrouperClientWs.mostRecentRequest,
18777 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18778 assertTrue(GrouperClientWs.mostRecentRequest,
18779 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18780 assertTrue(GrouperClientWs.mostRecentRequest,
18781 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18782 assertTrue(GrouperClientWs.mostRecentRequest,
18783 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18784 assertTrue(GrouperClientWs.mostRecentResponse,
18785 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
18786 assertTrue(GrouperClientWs.mostRecentRequest,
18787 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18788 assertTrue(GrouperClientWs.mostRecentRequest,
18789 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18790 assertTrue(GrouperClientWs.mostRecentRequest,
18791 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18792 assertTrue(GrouperClientWs.mostRecentRequest,
18793 !GrouperClientWs.mostRecentRequest.contains("params"));
18794 assertTrue(GrouperClientWs.mostRecentRequest,
18795 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18796 assertTrue(GrouperClientWs.mostRecentRequest,
18797 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18798 assertTrue(GrouperClientWs.mostRecentRequest,
18799 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18800 assertTrue(GrouperClientWs.mostRecentRequest,
18801 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18802 assertTrue(GrouperClientWs.mostRecentRequest,
18803 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18804 assertTrue(GrouperClientWs.mostRecentRequest,
18805 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18806
18807
18808
18809
18810 baos = new ByteArrayOutputStream();
18811 System.setOut(new PrintStream(baos));
18812
18813 args = new ArrayList<String>();
18814 args.add("--operation=getPermissionAssignmentsWs");
18815 args.add("--roleNames=" + role.getName());
18816 args.add("--subjectAttributeNames=abc");
18817 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18818 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18819 GrouperClient.main(args.toArray(new String[0]));
18820
18821 System.out.flush();
18822 output = new String(baos.toByteArray());
18823
18824 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18825
18826 System.setOut(systemOut);
18827
18828
18829 assertEquals(1, outputLines.length);
18830 outputLine = outputLines[0];
18831
18832 matcher = pattern.matcher(outputLines[0]);
18833
18834 assertTrue(outputLine, matcher.matches());
18835 assertEquals(outputLine, "0", matcher.group(1));
18836 assertEquals(outputLine, "role", matcher.group(2));
18837 assertEquals(outputLine, "aStem:role", matcher.group(3));
18838 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18839 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18840 assertEquals(outputLine, "action", matcher.group(6));
18841
18842
18843 assertTrue(GrouperClientWs.mostRecentRequest,
18844 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18845 assertTrue(GrouperClientWs.mostRecentRequest,
18846 !GrouperClientWs.mostRecentRequest.contains("actions"));
18847 assertTrue(GrouperClientWs.mostRecentRequest,
18848 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18849 assertTrue(GrouperClientWs.mostRecentRequest,
18850 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18851 assertTrue(GrouperClientWs.mostRecentRequest,
18852 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18853 assertTrue(GrouperClientWs.mostRecentRequest,
18854 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18855 assertTrue(GrouperClientWs.mostRecentRequest,
18856 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18857 assertTrue(GrouperClientWs.mostRecentResponse,
18858 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
18859 assertTrue(GrouperClientWs.mostRecentRequest,
18860 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18861 assertTrue(GrouperClientWs.mostRecentRequest,
18862 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18863 assertTrue(GrouperClientWs.mostRecentRequest,
18864 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18865 assertTrue(GrouperClientWs.mostRecentRequest,
18866 !GrouperClientWs.mostRecentRequest.contains("params"));
18867 assertTrue(GrouperClientWs.mostRecentRequest,
18868 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames") && GrouperClientWs.mostRecentRequest.contains("abc"));
18869 assertTrue(GrouperClientWs.mostRecentRequest,
18870 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18871 assertTrue(GrouperClientWs.mostRecentRequest,
18872 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18873 assertTrue(GrouperClientWs.mostRecentRequest,
18874 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18875 assertTrue(GrouperClientWs.mostRecentRequest,
18876 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18877 assertTrue(GrouperClientWs.mostRecentRequest,
18878 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18879
18880
18881
18882
18883 baos = new ByteArrayOutputStream();
18884 System.setOut(new PrintStream(baos));
18885
18886 args = new ArrayList<String>();
18887 args.add("--operation=getPermissionAssignmentsWs");
18888 args.add("--roleNames=" + role.getName());
18889 args.add("--paramName0=a");
18890 args.add("--paramValue0=b");
18891 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18892 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18893 GrouperClient.main(args.toArray(new String[0]));
18894
18895 System.out.flush();
18896 output = new String(baos.toByteArray());
18897
18898 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18899
18900 System.setOut(systemOut);
18901
18902
18903 assertEquals(1, outputLines.length);
18904 outputLine = outputLines[0];
18905
18906 matcher = pattern.matcher(outputLines[0]);
18907
18908 assertTrue(outputLine, matcher.matches());
18909 assertEquals(outputLine, "0", matcher.group(1));
18910 assertEquals(outputLine, "role", matcher.group(2));
18911 assertEquals(outputLine, "aStem:role", matcher.group(3));
18912 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18913 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18914 assertEquals(outputLine, "action", matcher.group(6));
18915
18916
18917 assertTrue(GrouperClientWs.mostRecentRequest,
18918 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18919 assertTrue(GrouperClientWs.mostRecentRequest,
18920 !GrouperClientWs.mostRecentRequest.contains("actions"));
18921 assertTrue(GrouperClientWs.mostRecentRequest,
18922 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18923 assertTrue(GrouperClientWs.mostRecentRequest,
18924 !GrouperClientWs.mostRecentRequest.contains("enabled"));
18925 assertTrue(GrouperClientWs.mostRecentRequest,
18926 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18927 assertTrue(GrouperClientWs.mostRecentRequest,
18928 !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18929 assertTrue(GrouperClientWs.mostRecentRequest,
18930 !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18931 assertTrue(GrouperClientWs.mostRecentResponse,
18932 !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
18933 assertTrue(GrouperClientWs.mostRecentRequest,
18934 !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18935 assertTrue(GrouperClientWs.mostRecentRequest,
18936 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18937 assertTrue(GrouperClientWs.mostRecentRequest,
18938 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18939 assertTrue(GrouperClientWs.mostRecentRequest,
18940 GrouperClientWs.mostRecentRequest.contains("params"));
18941 assertTrue(GrouperClientWs.mostRecentRequest,
18942 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18943 assertTrue(GrouperClientWs.mostRecentRequest,
18944 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18945 assertTrue(GrouperClientWs.mostRecentRequest,
18946 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18947 assertTrue(GrouperClientWs.mostRecentRequest,
18948 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18949 assertTrue(GrouperClientWs.mostRecentRequest,
18950 GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18951 assertTrue(GrouperClientWs.mostRecentRequest,
18952 !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18953
18954
18955
18956
18957 baos = new ByteArrayOutputStream();
18958 System.setOut(new PrintStream(baos));
18959
18960 args = new ArrayList<String>();
18961 args.add("--operation=getPermissionAssignmentsWs");
18962 args.add("--roleNames=" + role.getName());
18963 args.add("--actAsSubjectId=" + SubjectTestHelper.SUBJ0_ID);
18964 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18965 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18966
18967 try {
18968 GrouperClient.main(args.toArray(new String[0]));
18969 } catch (Exception e) {
18970 assertTrue(ExceptionUtils.getFullStackTrace(e).contains("GROUP_NOT_FOUND"));
18971 }
18972 System.out.flush();
18973
18974 System.setOut(systemOut);
18975
18976
18977
18978
18979
18980
18981 baos = new ByteArrayOutputStream();
18982 System.setOut(new PrintStream(baos));
18983
18984 args = new ArrayList<String>();
18985 args.add("--operation=getPermissionAssignmentsWs");
18986 args.add("--roleNames=" + role.getName());
18987 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(after));
18988 GrouperClient.main(args.toArray(new String[0]));
18989
18990 System.out.flush();
18991 output = new String(baos.toByteArray());
18992
18993 System.setOut(systemOut);
18994
18995 outputLines = GrouperClientUtils.splitTrim(output, "\n");
18996
18997 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
18998
18999
19000
19001
19002 baos = new ByteArrayOutputStream();
19003 System.setOut(new PrintStream(baos));
19004
19005 args = new ArrayList<String>();
19006 args.add("--operation=getPermissionAssignmentsWs");
19007 args.add("--roleNames=" + role.getName());
19008 args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(before));
19009 GrouperClient.main(args.toArray(new String[0]));
19010
19011 System.out.flush();
19012 output = new String(baos.toByteArray());
19013
19014 System.setOut(systemOut);
19015
19016 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19017
19018 assertEquals(1, outputLines.length);
19019 outputLine = outputLines[0];
19020
19021 matcher = pattern.matcher(outputLines[0]);
19022
19023 assertTrue(outputLine, matcher.matches());
19024 assertEquals(outputLine, "0", matcher.group(1));
19025 assertEquals(outputLine, "role", matcher.group(2));
19026 assertEquals(outputLine, "aStem:role", matcher.group(3));
19027 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
19028 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
19029 assertEquals(outputLine, "action", matcher.group(6));
19030
19031
19032
19033
19034
19035 baos = new ByteArrayOutputStream();
19036 System.setOut(new PrintStream(baos));
19037
19038 args = new ArrayList<String>();
19039 args.add("--operation=getPermissionAssignmentsWs");
19040 args.add("--roleNames=" + role.getName());
19041 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(before));
19042 GrouperClient.main(args.toArray(new String[0]));
19043
19044 System.out.flush();
19045 output = new String(baos.toByteArray());
19046
19047 System.setOut(systemOut);
19048
19049 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19050
19051 assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
19052
19053
19054
19055
19056 baos = new ByteArrayOutputStream();
19057 System.setOut(new PrintStream(baos));
19058
19059 args = new ArrayList<String>();
19060 args.add("--operation=getPermissionAssignmentsWs");
19061 args.add("--roleNames=" + role.getName());
19062 args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(after));
19063 GrouperClient.main(args.toArray(new String[0]));
19064
19065 System.out.flush();
19066 output = new String(baos.toByteArray());
19067
19068 System.setOut(systemOut);
19069
19070 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19071
19072 assertEquals(1, outputLines.length);
19073 outputLine = outputLines[0];
19074
19075 matcher = pattern.matcher(outputLines[0]);
19076
19077 assertTrue(outputLine, matcher.matches());
19078 assertEquals(outputLine, "0", matcher.group(1));
19079 assertEquals(outputLine, "role", matcher.group(2));
19080 assertEquals(outputLine, "aStem:role", matcher.group(3));
19081 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
19082 assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
19083 assertEquals(outputLine, "action", matcher.group(6));
19084
19085
19086 } finally {
19087 System.setOut(systemOut);
19088 }
19089
19090 }
19091
19092
19093
19094
19095 public void testAssignPermissions() throws Exception {
19096
19097 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb(
19098 AttributeDefType.perm, "test", "testAttributeAssignDefName");
19099
19100 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
19101
19102 attributeDef.setAssignToEffMembership(true);
19103 attributeDef.setAssignToGroup(true);
19104 attributeDef.store();
19105
19106 Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
19107 .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
19108 .assignDescription("description").assignTypeOfGroup(TypeOfGroup.role).save();
19109
19110
19111 group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
19112 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
19113
19114 AttributeAssign attributeAssign = null;
19115
19116
19117
19118 PrintStream systemOut = System.out;
19119
19120 ByteArrayOutputStream baos = new ByteArrayOutputStream();
19121 System.setOut(new PrintStream(baos));
19122
19123 try {
19124
19125 GrouperClient.main(GrouperClientUtils.splitTrim(
19126 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19127 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign",
19128 " "));
19129
19130 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19131
19132 System.out.flush();
19133 String output = new String(baos.toByteArray());
19134
19135 System.setOut(systemOut);
19136
19137 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
19138
19139
19140
19141 Pattern pattern = Pattern
19142 .compile("^Index\\: (\\d+)\\: permissionType\\: (.+), owner\\: (.+), permissionDefNameName\\: (.+), action\\: (.+), disallowed\\: (.+), enabled\\: (T|F), attributeAssignId\\: (.+), changed\\: (T|F), deleted\\: (T|F)$");
19143 String outputLine = outputLines[0];
19144
19145 Matcher matcher = pattern.matcher(outputLines[0]);
19146
19147 assertTrue(outputLine, matcher.matches());
19148 assertEquals(outputLine, "0", matcher.group(1));
19149 assertEquals(outputLine, "role", matcher.group(2));
19150 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19151 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19152 assertEquals(outputLine, "assign", matcher.group(5));
19153
19154 assertEquals(outputLine, "F", matcher.group(6));
19155 assertEquals(outputLine, "T", matcher.group(7));
19156 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19157 assertEquals(outputLine, "T", matcher.group(9));
19158
19159
19160 assertTrue(GrouperClientWs.mostRecentRequest,
19161 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19162 assertTrue(GrouperClientWs.mostRecentRequest,
19163 !GrouperClientWs.mostRecentRequest.contains("actions"));
19164 assertTrue(GrouperClientWs.mostRecentRequest,
19165 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19166 assertTrue(GrouperClientWs.mostRecentRequest,
19167 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19168 assertTrue(GrouperClientWs.mostRecentRequest,
19169 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19170 assertTrue(GrouperClientWs.mostRecentRequest,
19171 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19172 assertTrue(GrouperClientWs.mostRecentRequest,
19173 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19174 assertTrue(GrouperClientWs.mostRecentRequest,
19175 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19176 assertTrue(GrouperClientWs.mostRecentRequest,
19177 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19178 assertTrue(GrouperClientWs.mostRecentRequest,
19179 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19180 assertTrue(GrouperClientWs.mostRecentRequest,
19181 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19182 assertTrue(GrouperClientWs.mostRecentRequest,
19183 !GrouperClientWs.mostRecentRequest.contains("params"));
19184 assertTrue(GrouperClientWs.mostRecentRequest,
19185 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19186 assertTrue(GrouperClientWs.mostRecentRequest,
19187 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19188 assertTrue(GrouperClientWs.mostRecentRequest,
19189 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19190 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19191 assertTrue(GrouperClientWs.mostRecentRequest,
19192 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19193 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19194 assertTrue(GrouperClientWs.mostRecentRequest,
19195 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19196 assertTrue(GrouperClientWs.mostRecentResponse,
19197 GrouperClientWs.mostRecentResponse.contains("disallowed"));
19198
19199
19200
19201
19202 baos = new ByteArrayOutputStream();
19203 System.setOut(new PrintStream(baos));
19204
19205 GrouperClient.main(GrouperClientUtils.splitTrim(
19206 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19207 "--permissionDefNameUuids=" + attributeDefName.getId() + " --roleNames=test:groupTestAttrAssign",
19208 " "));
19209
19210 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19211
19212 System.out.flush();
19213 output = new String(baos.toByteArray());
19214
19215 System.setOut(systemOut);
19216
19217 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19218
19219 outputLine = outputLines[0];
19220
19221 matcher = pattern.matcher(outputLines[0]);
19222
19223 assertTrue(outputLine, matcher.matches());
19224 assertEquals(outputLine, "0", matcher.group(1));
19225 assertEquals(outputLine, "role", matcher.group(2));
19226 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19227 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19228 assertEquals(outputLine, "assign", matcher.group(5));
19229
19230 assertEquals(outputLine, "F", matcher.group(6));
19231 assertEquals(outputLine, "T", matcher.group(7));
19232 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19233 assertEquals(outputLine, "F", matcher.group(9));
19234
19235
19236 assertTrue(GrouperClientWs.mostRecentRequest,
19237 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19238 assertTrue(GrouperClientWs.mostRecentRequest,
19239 !GrouperClientWs.mostRecentRequest.contains("actions"));
19240 assertTrue(GrouperClientWs.mostRecentRequest,
19241 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19242 assertTrue(GrouperClientWs.mostRecentRequest,
19243 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19244 assertTrue(GrouperClientWs.mostRecentRequest,
19245 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19246 assertTrue(GrouperClientWs.mostRecentRequest,
19247 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19248 assertTrue(GrouperClientWs.mostRecentRequest,
19249 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19250 assertTrue(GrouperClientWs.mostRecentRequest,
19251 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19252 assertTrue(GrouperClientWs.mostRecentRequest,
19253 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19254 assertTrue(GrouperClientWs.mostRecentRequest,
19255 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19256 assertTrue(GrouperClientWs.mostRecentRequest,
19257 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19258 assertTrue(GrouperClientWs.mostRecentRequest,
19259 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19260 assertTrue(GrouperClientWs.mostRecentRequest,
19261 !GrouperClientWs.mostRecentRequest.contains("params"));
19262 assertTrue(GrouperClientWs.mostRecentRequest,
19263 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19264 assertTrue(GrouperClientWs.mostRecentRequest,
19265 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19266 assertTrue(GrouperClientWs.mostRecentRequest,
19267 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19268 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
19269 assertTrue(GrouperClientWs.mostRecentRequest,
19270 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19271 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19272 assertTrue(GrouperClientWs.mostRecentRequest,
19273 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19274
19275
19276
19277
19278
19279 baos = new ByteArrayOutputStream();
19280 System.setOut(new PrintStream(baos));
19281
19282 GrouperClient.main(GrouperClientUtils.splitTrim(
19283 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19284 "--permissionDefNameIdIndexes=" + attributeDefName.getIdIndex() + " --roleNames=test:groupTestAttrAssign",
19285 " "));
19286
19287 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19288
19289 System.out.flush();
19290 output = new String(baos.toByteArray());
19291
19292 System.setOut(systemOut);
19293
19294 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19295
19296 outputLine = outputLines[0];
19297
19298 matcher = pattern.matcher(outputLines[0]);
19299
19300 assertTrue(outputLine, matcher.matches());
19301 assertEquals(outputLine, "0", matcher.group(1));
19302 assertEquals(outputLine, "role", matcher.group(2));
19303 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19304 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19305 assertEquals(outputLine, "assign", matcher.group(5));
19306
19307 assertEquals(outputLine, "F", matcher.group(6));
19308 assertEquals(outputLine, "T", matcher.group(7));
19309 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19310 assertEquals(outputLine, "F", matcher.group(9));
19311
19312
19313 assertTrue(GrouperClientWs.mostRecentRequest,
19314 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19315 assertTrue(GrouperClientWs.mostRecentRequest,
19316 !GrouperClientWs.mostRecentRequest.contains("actions"));
19317 assertTrue(GrouperClientWs.mostRecentRequest,
19318 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19319 assertTrue(GrouperClientWs.mostRecentRequest,
19320 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19321 assertTrue(GrouperClientWs.mostRecentRequest,
19322 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19323 assertTrue(GrouperClientWs.mostRecentRequest,
19324 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19325 assertTrue(GrouperClientWs.mostRecentRequest,
19326 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19327 assertTrue(GrouperClientWs.mostRecentRequest,
19328 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19329 assertTrue(GrouperClientWs.mostRecentRequest,
19330 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19331 assertTrue(GrouperClientWs.mostRecentRequest,
19332 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19333 assertTrue(GrouperClientWs.mostRecentRequest,
19334 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19335 assertTrue(GrouperClientWs.mostRecentRequest,
19336 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19337 assertTrue(GrouperClientWs.mostRecentRequest,
19338 !GrouperClientWs.mostRecentRequest.contains("params"));
19339 assertTrue(GrouperClientWs.mostRecentRequest,
19340 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19341 assertTrue(GrouperClientWs.mostRecentRequest,
19342 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19343 assertTrue(GrouperClientWs.mostRecentRequest,
19344 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19345 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getIdIndex().toString()));
19346 assertTrue(GrouperClientWs.mostRecentRequest,
19347 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19348 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19349 assertTrue(GrouperClientWs.mostRecentRequest,
19350 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19351
19352
19353
19354
19355 baos = new ByteArrayOutputStream();
19356 System.setOut(new PrintStream(baos));
19357
19358 GrouperClient.main(GrouperClientUtils.splitTrim(
19359 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19360 "--permissionDefNameNames=test:testAttributeAssignDefName --roleUuids=" + group.getUuid(),
19361 " "));
19362
19363 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19364
19365 System.out.flush();
19366 output = new String(baos.toByteArray());
19367
19368 System.setOut(systemOut);
19369
19370 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19371
19372 outputLine = outputLines[0];
19373
19374 matcher = pattern.matcher(outputLines[0]);
19375
19376 assertTrue(outputLine, matcher.matches());
19377 assertEquals(outputLine, "0", matcher.group(1));
19378 assertEquals(outputLine, "role", matcher.group(2));
19379 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19380 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19381 assertEquals(outputLine, "assign", matcher.group(5));
19382
19383 assertEquals(outputLine, "F", matcher.group(6));
19384 assertEquals(outputLine, "T", matcher.group(7));
19385 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19386 assertEquals(outputLine, "F", matcher.group(9));
19387
19388
19389 assertTrue(GrouperClientWs.mostRecentRequest,
19390 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19391 assertTrue(GrouperClientWs.mostRecentRequest,
19392 !GrouperClientWs.mostRecentRequest.contains("actions"));
19393 assertTrue(GrouperClientWs.mostRecentRequest,
19394 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19395 assertTrue(GrouperClientWs.mostRecentRequest,
19396 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19397 assertTrue(GrouperClientWs.mostRecentRequest,
19398 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19399 assertTrue(GrouperClientWs.mostRecentRequest,
19400 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19401 assertTrue(GrouperClientWs.mostRecentRequest,
19402 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19403 assertTrue(GrouperClientWs.mostRecentRequest,
19404 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19405 assertTrue(GrouperClientWs.mostRecentRequest,
19406 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19407 assertTrue(GrouperClientWs.mostRecentRequest,
19408 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19409 assertTrue(GrouperClientWs.mostRecentRequest,
19410 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19411 assertTrue(GrouperClientWs.mostRecentRequest,
19412 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19413 assertTrue(GrouperClientWs.mostRecentRequest,
19414 !GrouperClientWs.mostRecentRequest.contains("params"));
19415 assertTrue(GrouperClientWs.mostRecentRequest,
19416 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19417 assertTrue(GrouperClientWs.mostRecentRequest,
19418 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19419 assertTrue(GrouperClientWs.mostRecentRequest,
19420 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19421 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19422 assertTrue(GrouperClientWs.mostRecentRequest,
19423 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19424 && GrouperClientWs.mostRecentRequest.contains(group.getUuid()));
19425 assertTrue(GrouperClientWs.mostRecentRequest,
19426 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19427
19428
19429
19430
19431 baos = new ByteArrayOutputStream();
19432 System.setOut(new PrintStream(baos));
19433
19434 GrouperClient.main(GrouperClientUtils.splitTrim(
19435 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19436 "--permissionDefNameNames=test:testAttributeAssignDefName --roleIdIndexes=" + group.getIdIndex(),
19437 " "));
19438
19439 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19440
19441 System.out.flush();
19442 output = new String(baos.toByteArray());
19443
19444 System.setOut(systemOut);
19445
19446 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19447
19448 outputLine = outputLines[0];
19449
19450 matcher = pattern.matcher(outputLines[0]);
19451
19452 assertTrue(outputLine, matcher.matches());
19453 assertEquals(outputLine, "0", matcher.group(1));
19454 assertEquals(outputLine, "role", matcher.group(2));
19455 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19456 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19457 assertEquals(outputLine, "assign", matcher.group(5));
19458
19459 assertEquals(outputLine, "F", matcher.group(6));
19460 assertEquals(outputLine, "T", matcher.group(7));
19461 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19462 assertEquals(outputLine, "F", matcher.group(9));
19463
19464
19465 assertTrue(GrouperClientWs.mostRecentRequest,
19466 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19467 assertTrue(GrouperClientWs.mostRecentRequest,
19468 !GrouperClientWs.mostRecentRequest.contains("actions"));
19469 assertTrue(GrouperClientWs.mostRecentRequest,
19470 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19471 assertTrue(GrouperClientWs.mostRecentRequest,
19472 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19473 assertTrue(GrouperClientWs.mostRecentRequest,
19474 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19475 assertTrue(GrouperClientWs.mostRecentRequest,
19476 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19477 assertTrue(GrouperClientWs.mostRecentRequest,
19478 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19479 assertTrue(GrouperClientWs.mostRecentRequest,
19480 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19481 assertTrue(GrouperClientWs.mostRecentRequest,
19482 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19483 assertTrue(GrouperClientWs.mostRecentRequest,
19484 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19485 assertTrue(GrouperClientWs.mostRecentRequest,
19486 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19487 assertTrue(GrouperClientWs.mostRecentRequest,
19488 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19489 assertTrue(GrouperClientWs.mostRecentRequest,
19490 !GrouperClientWs.mostRecentRequest.contains("params"));
19491 assertTrue(GrouperClientWs.mostRecentRequest,
19492 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19493 assertTrue(GrouperClientWs.mostRecentRequest,
19494 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19495 assertTrue(GrouperClientWs.mostRecentRequest,
19496 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19497 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19498 assertTrue(GrouperClientWs.mostRecentRequest,
19499 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19500 && GrouperClientWs.mostRecentRequest.contains(group.getIdIndex().toString()));
19501 assertTrue(GrouperClientWs.mostRecentRequest,
19502 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19503
19504
19505
19506
19507 baos = new ByteArrayOutputStream();
19508 System.setOut(new PrintStream(baos));
19509
19510 GrouperClient.main(GrouperClientUtils.splitTrim(
19511 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19512 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19513 + " --assignmentEnabledTime=2010/03/05_17:05:13.123",
19514 " "));
19515
19516 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19517
19518 System.out.flush();
19519 output = new String(baos.toByteArray());
19520
19521 System.setOut(systemOut);
19522
19523 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19524
19525 outputLine = outputLines[0];
19526
19527 matcher = pattern.matcher(outputLines[0]);
19528
19529 assertTrue(outputLine, matcher.matches());
19530 assertEquals(outputLine, "0", matcher.group(1));
19531 assertEquals(outputLine, "role", matcher.group(2));
19532 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19533 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19534 assertEquals(outputLine, "assign", matcher.group(5));
19535
19536 assertEquals(outputLine, "F", matcher.group(6));
19537 assertEquals(outputLine, "T", matcher.group(7));
19538 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19539 assertEquals(outputLine, "T", matcher.group(9));
19540
19541
19542 assertTrue(GrouperClientWs.mostRecentRequest,
19543 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19544 assertTrue(GrouperClientWs.mostRecentRequest,
19545 !GrouperClientWs.mostRecentRequest.contains("actions"));
19546 assertTrue(GrouperClientWs.mostRecentRequest,
19547 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19548 assertTrue(GrouperClientWs.mostRecentRequest,
19549 GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime")
19550 && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
19551 assertTrue(GrouperClientWs.mostRecentResponse,
19552 GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
19553 assertTrue(GrouperClientWs.mostRecentRequest,
19554 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19555 assertTrue(GrouperClientWs.mostRecentRequest,
19556 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19557 assertTrue(GrouperClientWs.mostRecentRequest,
19558 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19559 assertTrue(GrouperClientWs.mostRecentRequest,
19560 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19561 assertTrue(GrouperClientWs.mostRecentRequest,
19562 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19563 assertTrue(GrouperClientWs.mostRecentRequest,
19564 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19565 assertTrue(GrouperClientWs.mostRecentRequest,
19566 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19567 assertTrue(GrouperClientWs.mostRecentRequest,
19568 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19569 assertTrue(GrouperClientWs.mostRecentRequest,
19570 !GrouperClientWs.mostRecentRequest.contains("params"));
19571 assertTrue(GrouperClientWs.mostRecentRequest,
19572 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19573 assertTrue(GrouperClientWs.mostRecentRequest,
19574 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19575 assertTrue(GrouperClientWs.mostRecentRequest,
19576 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19577 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19578 assertTrue(GrouperClientWs.mostRecentRequest,
19579 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19580 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19581 assertTrue(GrouperClientWs.mostRecentRequest,
19582 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19583
19584
19585
19586
19587 baos = new ByteArrayOutputStream();
19588 System.setOut(new PrintStream(baos));
19589
19590 GrouperClient.main(GrouperClientUtils.splitTrim(
19591 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19592 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19593 + " --assignmentDisabledTime=2010/03/05_17:05:13.123",
19594 " "));
19595
19596 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19597
19598 System.out.flush();
19599 output = new String(baos.toByteArray());
19600
19601 System.setOut(systemOut);
19602
19603 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19604
19605 outputLine = outputLines[0];
19606
19607 matcher = pattern.matcher(outputLines[0]);
19608
19609 assertTrue(outputLine, matcher.matches());
19610 assertEquals(outputLine, "0", matcher.group(1));
19611 assertEquals(outputLine, "role", matcher.group(2));
19612 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19613 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19614 assertEquals(outputLine, "assign", matcher.group(5));
19615
19616 assertEquals(outputLine, "F", matcher.group(6));
19617 assertEquals(outputLine, "F", matcher.group(7));
19618 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19619 assertEquals(outputLine, "T", matcher.group(9));
19620
19621
19622 assertTrue(GrouperClientWs.mostRecentRequest,
19623 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19624 assertTrue(GrouperClientWs.mostRecentRequest,
19625 !GrouperClientWs.mostRecentRequest.contains("actions"));
19626 assertTrue(GrouperClientWs.mostRecentRequest,
19627 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19628 assertTrue(GrouperClientWs.mostRecentRequest,
19629 GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime")
19630 && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
19631 assertTrue(GrouperClientWs.mostRecentResponse,
19632 GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
19633 assertTrue(GrouperClientWs.mostRecentRequest,
19634 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19635 assertTrue(GrouperClientWs.mostRecentRequest,
19636 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19637 assertTrue(GrouperClientWs.mostRecentRequest,
19638 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19639 assertTrue(GrouperClientWs.mostRecentRequest,
19640 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19641 assertTrue(GrouperClientWs.mostRecentRequest,
19642 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19643 assertTrue(GrouperClientWs.mostRecentRequest,
19644 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19645 assertTrue(GrouperClientWs.mostRecentRequest,
19646 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19647 assertTrue(GrouperClientWs.mostRecentRequest,
19648 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19649 assertTrue(GrouperClientWs.mostRecentRequest,
19650 !GrouperClientWs.mostRecentRequest.contains("params"));
19651 assertTrue(GrouperClientWs.mostRecentRequest,
19652 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19653 assertTrue(GrouperClientWs.mostRecentRequest,
19654 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19655 assertTrue(GrouperClientWs.mostRecentRequest,
19656 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19657 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19658 assertTrue(GrouperClientWs.mostRecentRequest,
19659 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19660 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19661 assertTrue(GrouperClientWs.mostRecentRequest,
19662 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19663
19664
19665
19666
19667 baos = new ByteArrayOutputStream();
19668 System.setOut(new PrintStream(baos));
19669
19670 GrouperClient.main(GrouperClientUtils.splitTrim(
19671 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19672 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19673 + " --assignmentNotes=theNotes",
19674 " "));
19675
19676 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19677
19678 System.out.flush();
19679 output = new String(baos.toByteArray());
19680
19681 System.setOut(systemOut);
19682
19683 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19684
19685 outputLine = outputLines[0];
19686
19687 matcher = pattern.matcher(outputLines[0]);
19688
19689 assertTrue(outputLine, matcher.matches());
19690 assertEquals(outputLine, "0", matcher.group(1));
19691 assertEquals(outputLine, "role", matcher.group(2));
19692 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19693 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19694 assertEquals(outputLine, "assign", matcher.group(5));
19695
19696 assertEquals(outputLine, "F", matcher.group(6));
19697 assertEquals(outputLine, "T", matcher.group(7));
19698 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19699 assertEquals(outputLine, "T", matcher.group(9));
19700
19701
19702 assertTrue(GrouperClientWs.mostRecentRequest,
19703 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19704 assertTrue(GrouperClientWs.mostRecentRequest,
19705 !GrouperClientWs.mostRecentRequest.contains("actions"));
19706 assertTrue(GrouperClientWs.mostRecentRequest,
19707 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19708 assertTrue(GrouperClientWs.mostRecentRequest,
19709 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19710 assertTrue(GrouperClientWs.mostRecentResponse,
19711 GrouperClientWs.mostRecentResponse.contains("theNotes"));
19712 assertTrue(GrouperClientWs.mostRecentRequest,
19713 GrouperClientWs.mostRecentRequest.contains("assignmentNotes")
19714 && GrouperClientWs.mostRecentRequest.contains("theNotes") );
19715 assertTrue(GrouperClientWs.mostRecentRequest,
19716 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19717 assertTrue(GrouperClientWs.mostRecentRequest,
19718 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19719 assertTrue(GrouperClientWs.mostRecentRequest,
19720 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19721 assertTrue(GrouperClientWs.mostRecentRequest,
19722 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19723 assertTrue(GrouperClientWs.mostRecentRequest,
19724 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19725 assertTrue(GrouperClientWs.mostRecentRequest,
19726 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19727 assertTrue(GrouperClientWs.mostRecentRequest,
19728 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19729 assertTrue(GrouperClientWs.mostRecentRequest,
19730 !GrouperClientWs.mostRecentRequest.contains("params"));
19731 assertTrue(GrouperClientWs.mostRecentRequest,
19732 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19733 assertTrue(GrouperClientWs.mostRecentRequest,
19734 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19735 assertTrue(GrouperClientWs.mostRecentRequest,
19736 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19737 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19738 assertTrue(GrouperClientWs.mostRecentRequest,
19739 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19740 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19741 assertTrue(GrouperClientWs.mostRecentRequest,
19742 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19743
19744
19745
19746
19747
19748 baos = new ByteArrayOutputStream();
19749 System.setOut(new PrintStream(baos));
19750
19751 GrouperClient.main(GrouperClientUtils.splitTrim(
19752 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19753 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19754 + " --delegatable=FALSE",
19755 " "));
19756
19757 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19758
19759 System.out.flush();
19760 output = new String(baos.toByteArray());
19761
19762 System.setOut(systemOut);
19763
19764 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19765
19766 outputLine = outputLines[0];
19767
19768 matcher = pattern.matcher(outputLines[0]);
19769
19770 assertTrue(outputLine, matcher.matches());
19771 assertEquals(outputLine, "0", matcher.group(1));
19772 assertEquals(outputLine, "role", matcher.group(2));
19773 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19774 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19775 assertEquals(outputLine, "assign", matcher.group(5));
19776
19777 assertEquals(outputLine, "F", matcher.group(6));
19778 assertEquals(outputLine, "T", matcher.group(7));
19779 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19780 assertEquals(outputLine, "T", matcher.group(9));
19781
19782
19783 assertTrue(GrouperClientWs.mostRecentRequest,
19784 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19785 assertTrue(GrouperClientWs.mostRecentRequest,
19786 !GrouperClientWs.mostRecentRequest.contains("actions"));
19787 assertTrue(GrouperClientWs.mostRecentRequest,
19788 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19789 assertTrue(GrouperClientWs.mostRecentRequest,
19790 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19791
19792
19793 assertTrue(GrouperClientWs.mostRecentRequest,
19794 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19795 assertTrue(GrouperClientWs.mostRecentRequest,
19796 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19797 assertTrue(GrouperClientWs.mostRecentRequest,
19798 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19799 assertTrue(GrouperClientWs.mostRecentRequest,
19800 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19801 assertTrue(GrouperClientWs.mostRecentRequest,
19802 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19803 assertTrue(GrouperClientWs.mostRecentRequest,
19804 GrouperClientWs.mostRecentRequest.contains("delegatable")
19805 && GrouperClientWs.mostRecentRequest.contains("FALSE"));
19806 assertTrue(GrouperClientWs.mostRecentRequest,
19807 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19808 assertTrue(GrouperClientWs.mostRecentRequest,
19809 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19810 assertTrue(GrouperClientWs.mostRecentRequest,
19811 !GrouperClientWs.mostRecentRequest.contains("params"));
19812 assertTrue(GrouperClientWs.mostRecentRequest,
19813 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19814 assertTrue(GrouperClientWs.mostRecentRequest,
19815 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19816 assertTrue(GrouperClientWs.mostRecentRequest,
19817 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19818 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19819 assertTrue(GrouperClientWs.mostRecentRequest,
19820 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19821 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19822 assertTrue(GrouperClientWs.mostRecentRequest,
19823 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19824
19825
19826
19827
19828 baos = new ByteArrayOutputStream();
19829 System.setOut(new PrintStream(baos));
19830
19831 GrouperClient.main(GrouperClientUtils.splitTrim(
19832 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19833 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19834 + " --actions=assign",
19835 " "));
19836
19837 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19838
19839 System.out.flush();
19840 output = new String(baos.toByteArray());
19841
19842 System.setOut(systemOut);
19843
19844 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19845
19846 outputLine = outputLines[0];
19847
19848 matcher = pattern.matcher(outputLines[0]);
19849
19850 assertTrue(outputLine, matcher.matches());
19851 assertEquals(outputLine, "0", matcher.group(1));
19852 assertEquals(outputLine, "role", matcher.group(2));
19853 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19854 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19855 assertEquals(outputLine, "assign", matcher.group(5));
19856
19857 assertEquals(outputLine, "F", matcher.group(6));
19858 assertEquals(outputLine, "T", matcher.group(7));
19859 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19860 assertEquals(outputLine, "F", matcher.group(9));
19861
19862
19863 assertTrue(GrouperClientWs.mostRecentRequest,
19864 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19865 assertTrue(GrouperClientWs.mostRecentRequest,
19866 GrouperClientWs.mostRecentRequest.contains("actions"));
19867 assertTrue(GrouperClientWs.mostRecentRequest,
19868 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19869 assertTrue(GrouperClientWs.mostRecentRequest,
19870 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19871
19872
19873 assertTrue(GrouperClientWs.mostRecentRequest,
19874 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19875 assertTrue(GrouperClientWs.mostRecentRequest,
19876 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19877 assertTrue(GrouperClientWs.mostRecentRequest,
19878 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19879 assertTrue(GrouperClientWs.mostRecentRequest,
19880 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19881 assertTrue(GrouperClientWs.mostRecentRequest,
19882 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19883 assertTrue(GrouperClientWs.mostRecentRequest,
19884 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19885 assertTrue(GrouperClientWs.mostRecentRequest,
19886 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19887 assertTrue(GrouperClientWs.mostRecentRequest,
19888 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19889 assertTrue(GrouperClientWs.mostRecentRequest,
19890 !GrouperClientWs.mostRecentRequest.contains("params"));
19891 assertTrue(GrouperClientWs.mostRecentRequest,
19892 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19893 assertTrue(GrouperClientWs.mostRecentRequest,
19894 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19895 assertTrue(GrouperClientWs.mostRecentRequest,
19896 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19897 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19898 assertTrue(GrouperClientWs.mostRecentRequest,
19899 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19900 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19901 assertTrue(GrouperClientWs.mostRecentRequest,
19902 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19903
19904
19905
19906
19907 baos = new ByteArrayOutputStream();
19908 System.setOut(new PrintStream(baos));
19909
19910 GrouperClient.main(GrouperClientUtils.splitTrim(
19911 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19912 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19913 + " --includeGroupDetail=T",
19914 " "));
19915
19916 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19917
19918 System.out.flush();
19919 output = new String(baos.toByteArray());
19920
19921 System.setOut(systemOut);
19922
19923 outputLines = GrouperClientUtils.splitTrim(output, "\n");
19924
19925 outputLine = outputLines[0];
19926
19927 matcher = pattern.matcher(outputLines[0]);
19928
19929 assertTrue(outputLine, matcher.matches());
19930 assertEquals(outputLine, "0", matcher.group(1));
19931 assertEquals(outputLine, "role", matcher.group(2));
19932 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19933 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19934 assertEquals(outputLine, "assign", matcher.group(5));
19935 assertEquals(outputLine, "F", matcher.group(6));
19936 assertEquals(outputLine, "T", matcher.group(7));
19937 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19938 assertEquals(outputLine, "F", matcher.group(9));
19939
19940
19941 assertTrue(GrouperClientWs.mostRecentRequest,
19942 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19943 assertTrue(GrouperClientWs.mostRecentRequest,
19944 !GrouperClientWs.mostRecentRequest.contains("actions"));
19945 assertTrue(GrouperClientWs.mostRecentRequest,
19946 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19947 assertTrue(GrouperClientWs.mostRecentRequest,
19948 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19949 assertTrue(GrouperClientWs.mostRecentRequest,
19950 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19951 assertTrue(GrouperClientWs.mostRecentRequest,
19952 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19953 assertTrue(GrouperClientWs.mostRecentRequest,
19954 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19955 assertTrue(GrouperClientWs.mostRecentRequest,
19956 GrouperClientWs.mostRecentRequest.contains("permissionType"));
19957 assertTrue(GrouperClientWs.mostRecentRequest,
19958 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19959 assertTrue(GrouperClientWs.mostRecentRequest,
19960 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19961 assertTrue(GrouperClientWs.mostRecentRequest,
19962 GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19963 assertTrue(GrouperClientWs.mostRecentRequest,
19964 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19965 assertTrue(GrouperClientWs.mostRecentRequest,
19966 !GrouperClientWs.mostRecentRequest.contains("params"));
19967 assertTrue(GrouperClientWs.mostRecentRequest,
19968 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19969 assertTrue(GrouperClientWs.mostRecentRequest,
19970 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19971 assertTrue(GrouperClientWs.mostRecentRequest,
19972 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19973 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19974 assertTrue(GrouperClientWs.mostRecentRequest,
19975 GrouperClientWs.mostRecentRequest.contains("roleLookups")
19976 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19977 assertTrue(GrouperClientWs.mostRecentRequest,
19978 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19979
19980
19981
19982
19983
19984 baos = new ByteArrayOutputStream();
19985 System.setOut(new PrintStream(baos));
19986
19987 GrouperClient.main(GrouperClientUtils.splitTrim(
19988 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19989 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19990 + " --includeSubjectDetail=T",
19991 " "));
19992
19993 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19994
19995 System.out.flush();
19996 output = new String(baos.toByteArray());
19997
19998 System.setOut(systemOut);
19999
20000 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20001
20002 outputLine = outputLines[0];
20003
20004 matcher = pattern.matcher(outputLines[0]);
20005
20006 assertTrue(outputLine, matcher.matches());
20007 assertEquals(outputLine, "0", matcher.group(1));
20008 assertEquals(outputLine, "role", matcher.group(2));
20009 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20010 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20011 assertEquals(outputLine, "assign", matcher.group(5));
20012 assertEquals(outputLine, "F", matcher.group(6));
20013 assertEquals(outputLine, "T", matcher.group(7));
20014 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20015 assertEquals(outputLine, "F", matcher.group(9));
20016
20017
20018 assertTrue(GrouperClientWs.mostRecentRequest,
20019 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20020 assertTrue(GrouperClientWs.mostRecentRequest,
20021 !GrouperClientWs.mostRecentRequest.contains("actions"));
20022 assertTrue(GrouperClientWs.mostRecentRequest,
20023 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20024 assertTrue(GrouperClientWs.mostRecentRequest,
20025 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20026 assertTrue(GrouperClientWs.mostRecentRequest,
20027 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20028 assertTrue(GrouperClientWs.mostRecentRequest,
20029 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20030 assertTrue(GrouperClientWs.mostRecentRequest,
20031 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20032 assertTrue(GrouperClientWs.mostRecentRequest,
20033 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20034 assertTrue(GrouperClientWs.mostRecentRequest,
20035 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20036 assertTrue(GrouperClientWs.mostRecentRequest,
20037 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20038 assertTrue(GrouperClientWs.mostRecentRequest,
20039 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20040 assertTrue(GrouperClientWs.mostRecentRequest,
20041 GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20042 assertTrue(GrouperClientWs.mostRecentRequest,
20043 !GrouperClientWs.mostRecentRequest.contains("params"));
20044 assertTrue(GrouperClientWs.mostRecentRequest,
20045 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20046 assertTrue(GrouperClientWs.mostRecentRequest,
20047 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20048 assertTrue(GrouperClientWs.mostRecentRequest,
20049 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20050 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20051 assertTrue(GrouperClientWs.mostRecentRequest,
20052 GrouperClientWs.mostRecentRequest.contains("roleLookups")
20053 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20054 assertTrue(GrouperClientWs.mostRecentRequest,
20055 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20056
20057
20058
20059
20060
20061 baos = new ByteArrayOutputStream();
20062 System.setOut(new PrintStream(baos));
20063
20064 GrouperClient.main(GrouperClientUtils.splitTrim(
20065 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
20066 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
20067 + " --subjectAttributeNames=abc",
20068 " "));
20069
20070 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
20071
20072 System.out.flush();
20073 output = new String(baos.toByteArray());
20074
20075 System.setOut(systemOut);
20076
20077 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20078
20079 outputLine = outputLines[0];
20080
20081 matcher = pattern.matcher(outputLines[0]);
20082
20083 assertTrue(outputLine, matcher.matches());
20084 assertEquals(outputLine, "0", matcher.group(1));
20085 assertEquals(outputLine, "role", matcher.group(2));
20086 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20087 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20088 assertEquals(outputLine, "assign", matcher.group(5));
20089 assertEquals(outputLine, "F", matcher.group(6));
20090 assertEquals(outputLine, "T", matcher.group(7));
20091 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20092 assertEquals(outputLine, "F", matcher.group(9));
20093
20094
20095 assertTrue(GrouperClientWs.mostRecentRequest,
20096 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20097 assertTrue(GrouperClientWs.mostRecentRequest,
20098 !GrouperClientWs.mostRecentRequest.contains("actions"));
20099 assertTrue(GrouperClientWs.mostRecentRequest,
20100 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20101 assertTrue(GrouperClientWs.mostRecentRequest,
20102 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20103 assertTrue(GrouperClientWs.mostRecentRequest,
20104 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20105 assertTrue(GrouperClientWs.mostRecentRequest,
20106 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20107 assertTrue(GrouperClientWs.mostRecentRequest,
20108 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20109 assertTrue(GrouperClientWs.mostRecentRequest,
20110 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20111 assertTrue(GrouperClientWs.mostRecentRequest,
20112 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20113 assertTrue(GrouperClientWs.mostRecentRequest,
20114 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20115 assertTrue(GrouperClientWs.mostRecentRequest,
20116 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20117 assertTrue(GrouperClientWs.mostRecentRequest,
20118 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20119 assertTrue(GrouperClientWs.mostRecentRequest,
20120 !GrouperClientWs.mostRecentRequest.contains("params"));
20121 assertTrue(GrouperClientWs.mostRecentRequest,
20122 GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20123 assertTrue(GrouperClientWs.mostRecentRequest,
20124 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20125 assertTrue(GrouperClientWs.mostRecentRequest,
20126 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20127 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20128 assertTrue(GrouperClientWs.mostRecentRequest,
20129 GrouperClientWs.mostRecentRequest.contains("roleLookups")
20130 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20131 assertTrue(GrouperClientWs.mostRecentRequest,
20132 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20133
20134
20135
20136
20137
20138 baos = new ByteArrayOutputStream();
20139 System.setOut(new PrintStream(baos));
20140
20141 GrouperClient.main(GrouperClientUtils.splitTrim(
20142 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
20143 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
20144 + " --paramName0=a --paramValue0=b",
20145 " "));
20146
20147 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
20148
20149 System.out.flush();
20150 output = new String(baos.toByteArray());
20151
20152 System.setOut(systemOut);
20153
20154 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20155
20156 outputLine = outputLines[0];
20157
20158 matcher = pattern.matcher(outputLines[0]);
20159
20160 assertTrue(outputLine, matcher.matches());
20161 assertEquals(outputLine, "0", matcher.group(1));
20162 assertEquals(outputLine, "role", matcher.group(2));
20163 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20164 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20165 assertEquals(outputLine, "assign", matcher.group(5));
20166 assertEquals(outputLine, "F", matcher.group(6));
20167 assertEquals(outputLine, "T", matcher.group(7));
20168 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20169 assertEquals(outputLine, "F", matcher.group(9));
20170
20171
20172 assertTrue(GrouperClientWs.mostRecentRequest,
20173 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20174 assertTrue(GrouperClientWs.mostRecentRequest,
20175 !GrouperClientWs.mostRecentRequest.contains("actions"));
20176 assertTrue(GrouperClientWs.mostRecentRequest,
20177 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20178 assertTrue(GrouperClientWs.mostRecentRequest,
20179 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20180 assertTrue(GrouperClientWs.mostRecentRequest,
20181 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20182 assertTrue(GrouperClientWs.mostRecentRequest,
20183 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20184 assertTrue(GrouperClientWs.mostRecentRequest,
20185 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20186 assertTrue(GrouperClientWs.mostRecentRequest,
20187 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20188 assertTrue(GrouperClientWs.mostRecentRequest,
20189 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20190 assertTrue(GrouperClientWs.mostRecentRequest,
20191 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20192 assertTrue(GrouperClientWs.mostRecentRequest,
20193 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20194 assertTrue(GrouperClientWs.mostRecentRequest,
20195 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20196 assertTrue(GrouperClientWs.mostRecentRequest,
20197 GrouperClientWs.mostRecentRequest.contains("params"));
20198 assertTrue(GrouperClientWs.mostRecentRequest,
20199 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20200 assertTrue(GrouperClientWs.mostRecentRequest,
20201 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20202 assertTrue(GrouperClientWs.mostRecentRequest,
20203 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20204 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20205 assertTrue(GrouperClientWs.mostRecentRequest,
20206 GrouperClientWs.mostRecentRequest.contains("roleLookups")
20207 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20208 assertTrue(GrouperClientWs.mostRecentRequest,
20209 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20210
20211
20212
20213
20214
20215 baos = new ByteArrayOutputStream();
20216 System.setOut(new PrintStream(baos));
20217
20218 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
20219
20220 String attributeAssignId = attributeAssign.getId();
20221
20222 GrouperClient.main(GrouperClientUtils.splitTrim(
20223 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=remove_permission "
20224 + " --attributeAssignUuids=" + attributeAssign.getId(),
20225 " "));
20226
20227 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20228
20229 assertNull("Should be deleted", attributeAssign);
20230
20231 System.out.flush();
20232 output = new String(baos.toByteArray());
20233
20234 System.setOut(systemOut);
20235
20236 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20237
20238 outputLine = outputLines[0];
20239
20240 matcher = pattern.matcher(outputLines[0]);
20241
20242 assertTrue(outputLine, matcher.matches());
20243 assertEquals(outputLine, "0", matcher.group(1));
20244 assertEquals(outputLine, "role", matcher.group(2));
20245 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20246 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20247 assertEquals(outputLine, "assign", matcher.group(5));
20248
20249 assertEquals(outputLine, "F", matcher.group(6));
20250 assertEquals(outputLine, "T", matcher.group(7));
20251 assertEquals(outputLine, attributeAssignId, matcher.group(8));
20252 assertEquals(outputLine, "T", matcher.group(9));
20253
20254
20255 assertTrue(GrouperClientWs.mostRecentRequest,
20256 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20257 assertTrue(GrouperClientWs.mostRecentRequest,
20258 !GrouperClientWs.mostRecentRequest.contains("actions"));
20259 assertTrue(GrouperClientWs.mostRecentRequest,
20260 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20261 assertTrue(GrouperClientWs.mostRecentRequest,
20262 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20263 assertTrue(GrouperClientWs.mostRecentRequest,
20264 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20265 assertTrue(GrouperClientWs.mostRecentRequest,
20266 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20267 assertTrue(GrouperClientWs.mostRecentRequest,
20268 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20269 assertTrue(GrouperClientWs.mostRecentRequest,
20270 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20271 assertTrue(GrouperClientWs.mostRecentRequest,
20272 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20273 assertTrue(GrouperClientWs.mostRecentRequest,
20274 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20275 assertTrue(GrouperClientWs.mostRecentRequest,
20276 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20277 assertTrue(GrouperClientWs.mostRecentRequest,
20278 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20279 assertTrue(GrouperClientWs.mostRecentRequest,
20280 !GrouperClientWs.mostRecentRequest.contains("params"));
20281 assertTrue(GrouperClientWs.mostRecentRequest,
20282 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20283 assertTrue(GrouperClientWs.mostRecentRequest,
20284 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20285 assertTrue(GrouperClientWs.mostRecentRequest,
20286 !GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20287 && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20288 assertTrue(GrouperClientWs.mostRecentRequest,
20289 !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20290 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20291 assertTrue(GrouperClientWs.mostRecentRequest,
20292 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20293
20294
20295
20296
20297 baos = new ByteArrayOutputStream();
20298 System.setOut(new PrintStream(baos));
20299
20300 attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
20301
20302 attributeAssignId = attributeAssign.getId();
20303
20304 GrouperClient.main(GrouperClientUtils.splitTrim(
20305 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=remove_permission "
20306 + " --attributeAssignUuids=" + attributeAssign.getId() + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
20307 " "));
20308
20309 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20310
20311 assertNull("Should be deleted", attributeAssign);
20312
20313 System.out.flush();
20314 output = new String(baos.toByteArray());
20315
20316 System.setOut(systemOut);
20317
20318 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20319
20320 outputLine = GrouperClientUtils.trim(outputLines[0]);
20321
20322 assertEquals(outputLine, "group", outputLine);
20323
20324 assertTrue(GrouperClientWs.mostRecentRequest,
20325 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20326 assertTrue(GrouperClientWs.mostRecentRequest,
20327 !GrouperClientWs.mostRecentRequest.contains("actions"));
20328 assertTrue(GrouperClientWs.mostRecentRequest,
20329 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20330 assertTrue(GrouperClientWs.mostRecentRequest,
20331 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20332 assertTrue(GrouperClientWs.mostRecentRequest,
20333 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20334 assertTrue(GrouperClientWs.mostRecentRequest,
20335 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20336 assertTrue(GrouperClientWs.mostRecentRequest,
20337 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20338 assertTrue(GrouperClientWs.mostRecentRequest,
20339 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20340 assertTrue(GrouperClientWs.mostRecentRequest,
20341 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20342 assertTrue(GrouperClientWs.mostRecentRequest,
20343 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20344 assertTrue(GrouperClientWs.mostRecentRequest,
20345 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20346 assertTrue(GrouperClientWs.mostRecentRequest,
20347 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20348 assertTrue(GrouperClientWs.mostRecentRequest,
20349 !GrouperClientWs.mostRecentRequest.contains("params"));
20350 assertTrue(GrouperClientWs.mostRecentRequest,
20351 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20352 assertTrue(GrouperClientWs.mostRecentRequest,
20353 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20354 assertTrue(GrouperClientWs.mostRecentRequest,
20355 !GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20356 && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20357 assertTrue(GrouperClientWs.mostRecentRequest,
20358 !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20359 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20360 assertTrue(GrouperClientWs.mostRecentRequest,
20361 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20362
20363
20364
20365
20366
20367 baos = new ByteArrayOutputStream();
20368 System.setOut(new PrintStream(baos));
20369
20370 attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
20371
20372 attributeAssignId = attributeAssign.getId();
20373
20374 GrouperClient.main(GrouperClientUtils.splitTrim(
20375 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=remove_permission "
20376 + " --attributeAssignUuids=" + attributeAssign.getId() + " --actAsSubjectId=GrouperSystem",
20377 " "));
20378
20379 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20380
20381 assertNull("Should be deleted", attributeAssign);
20382
20383 System.out.flush();
20384 output = new String(baos.toByteArray());
20385
20386 System.setOut(systemOut);
20387
20388 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20389
20390 outputLine = outputLines[0];
20391
20392 matcher = pattern.matcher(outputLines[0]);
20393
20394 assertTrue(outputLine, matcher.matches());
20395 assertEquals(outputLine, "0", matcher.group(1));
20396 assertEquals(outputLine, "role", matcher.group(2));
20397 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20398 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20399 assertEquals(outputLine, "assign", matcher.group(5));
20400
20401 assertEquals(outputLine, "F", matcher.group(6));
20402 assertEquals(outputLine, "T", matcher.group(7));
20403 assertEquals(outputLine, attributeAssignId, matcher.group(8));
20404 assertEquals(outputLine, "T", matcher.group(9));
20405
20406
20407 assertTrue(GrouperClientWs.mostRecentRequest,
20408 GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20409 assertTrue(GrouperClientWs.mostRecentRequest,
20410 !GrouperClientWs.mostRecentRequest.contains("actions"));
20411 assertTrue(GrouperClientWs.mostRecentRequest,
20412 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20413 assertTrue(GrouperClientWs.mostRecentRequest,
20414 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20415 assertTrue(GrouperClientWs.mostRecentRequest,
20416 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20417 assertTrue(GrouperClientWs.mostRecentRequest,
20418 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20419 assertTrue(GrouperClientWs.mostRecentRequest,
20420 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20421 assertTrue(GrouperClientWs.mostRecentRequest,
20422 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20423 assertTrue(GrouperClientWs.mostRecentRequest,
20424 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20425 assertTrue(GrouperClientWs.mostRecentRequest,
20426 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20427 assertTrue(GrouperClientWs.mostRecentRequest,
20428 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20429 assertTrue(GrouperClientWs.mostRecentRequest,
20430 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20431 assertTrue(GrouperClientWs.mostRecentRequest,
20432 !GrouperClientWs.mostRecentRequest.contains("params"));
20433 assertTrue(GrouperClientWs.mostRecentRequest,
20434 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20435 assertTrue(GrouperClientWs.mostRecentRequest,
20436 GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20437 assertTrue(GrouperClientWs.mostRecentRequest,
20438 !GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20439 && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20440 assertTrue(GrouperClientWs.mostRecentRequest,
20441 !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20442 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20443 assertTrue(GrouperClientWs.mostRecentRequest,
20444 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20445
20446
20447
20448
20449 baos = new ByteArrayOutputStream();
20450 System.setOut(new PrintStream(baos));
20451
20452 group.getAttributeDelegate().removeAttribute(attributeDefName);
20453
20454 GrouperClient.main(GrouperClientUtils.splitTrim(
20455 "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
20456 "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign --disallowed=true",
20457 " "));
20458
20459 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20460 attributeAssignId = attributeAssign.getId();
20461
20462 assertTrue("Should be disallowed", attributeAssign.isDisallowed());
20463
20464 System.out.flush();
20465 output = new String(baos.toByteArray());
20466
20467 System.setOut(systemOut);
20468
20469 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20470
20471 outputLine = outputLines[0];
20472
20473 matcher = pattern.matcher(outputLines[0]);
20474
20475 assertTrue(outputLine, matcher.matches());
20476 assertEquals(outputLine, "0", matcher.group(1));
20477 assertEquals(outputLine, "role", matcher.group(2));
20478 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20479 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20480 assertEquals(outputLine, "assign", matcher.group(5));
20481
20482 assertEquals(outputLine, "T", matcher.group(6));
20483 assertEquals(outputLine, "T", matcher.group(7));
20484 assertEquals(outputLine, attributeAssignId, matcher.group(8));
20485 assertEquals(outputLine, "T", matcher.group(9));
20486
20487
20488 assertTrue(GrouperClientWs.mostRecentRequest,
20489 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20490 assertTrue(GrouperClientWs.mostRecentRequest,
20491 !GrouperClientWs.mostRecentRequest.contains("actions"));
20492 assertTrue(GrouperClientWs.mostRecentRequest,
20493 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20494 assertTrue(GrouperClientWs.mostRecentRequest,
20495 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20496 assertTrue(GrouperClientWs.mostRecentRequest,
20497 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20498 assertTrue(GrouperClientWs.mostRecentRequest,
20499 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20500 assertTrue(GrouperClientWs.mostRecentRequest,
20501 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20502 assertTrue(GrouperClientWs.mostRecentRequest,
20503 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20504 assertTrue(GrouperClientWs.mostRecentRequest,
20505 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20506 assertTrue(GrouperClientWs.mostRecentRequest,
20507 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20508 assertTrue(GrouperClientWs.mostRecentRequest,
20509 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20510 assertTrue(GrouperClientWs.mostRecentRequest,
20511 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20512 assertTrue(GrouperClientWs.mostRecentRequest,
20513 !GrouperClientWs.mostRecentRequest.contains("params"));
20514 assertTrue(GrouperClientWs.mostRecentRequest,
20515 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20516 assertTrue(GrouperClientWs.mostRecentRequest,
20517 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20518 assertTrue(GrouperClientWs.mostRecentRequest,
20519 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20520 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20521 assertTrue(GrouperClientWs.mostRecentRequest,
20522 GrouperClientWs.mostRecentRequest.contains("roleLookups")
20523 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20524 assertTrue(GrouperClientWs.mostRecentRequest,
20525 !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20526 assertTrue(GrouperClientWs.mostRecentRequest,
20527 GrouperClientWs.mostRecentRequest.contains("disallowed"));
20528
20529
20530
20531 } finally {
20532 System.setOut(systemOut);
20533 }
20534
20535 }
20536
20537
20538
20539
20540 public void testAssignPermissionsAnyMembership() throws Exception {
20541
20542 GrouperSession grouperSession = GrouperSession.startRootSession();
20543
20544 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb(AttributeDefType.perm, "test", "testAttributeAssignDefName");
20545
20546 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
20547
20548 attributeDef.setAssignToGroup(false);
20549 attributeDef.setAssignToEffMembership(true);
20550 attributeDef.store();
20551
20552 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
20553 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
20554 .assignTypeOfGroup(TypeOfGroup.role).assignDescription("description").save();
20555
20556 Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
20557 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
20558 .assignDescription("description").save();
20559
20560
20561 group1.addMember(group2.toSubject());
20562 group2.addMember(SubjectTestHelper.SUBJ0);
20563
20564 Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, false);
20565
20566 Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
20567 GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
20568
20569
20570 AttributeAssign attributeAssign = null;
20571
20572 PrintStream systemOut = System.out;
20573
20574 ByteArrayOutputStream baos = new ByteArrayOutputStream();
20575 System.setOut(new PrintStream(baos));
20576
20577 try {
20578
20579 GrouperClient.main(GrouperClientUtils.splitTrim(
20580 "--operation=assignPermissionsWs --permissionType=role_subject --permissionAssignOperation=assign_permission " +
20581 "--permissionDefNameNames=test:testAttributeAssignDefName --subjectRole0SubjectId=" + member.getSubjectId()
20582 + " --subjectRole0RoleName=" + group1.getName(),
20583 " "));
20584
20585 attributeAssign = membership.getAttributeDelegateEffMship().retrieveAssignment("assign", attributeDefName, false, true);
20586
20587 System.out.flush();
20588 String output = new String(baos.toByteArray());
20589
20590 System.setOut(systemOut);
20591
20592 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
20593
20594
20595
20596 Pattern pattern = Pattern
20597 .compile("^Index\\: (\\d+)\\: permissionType\\: (.+), owner\\: (.+), permissionDefNameName\\: (.+), action\\: (.+), disallowed\\: (T|F), enabled\\: (T|F), attributeAssignId\\: (.+), changed\\: (T|F), deleted\\: (T|F)$");
20598 String outputLine = outputLines[0];
20599
20600 Matcher matcher = pattern.matcher(outputLines[0]);
20601
20602 assertTrue(outputLine, matcher.matches());
20603 assertEquals(outputLine, "0", matcher.group(1));
20604 assertEquals(outputLine, "role_subject", matcher.group(2));
20605 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
20606 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20607 assertEquals(outputLine, "assign", matcher.group(5));
20608
20609 assertEquals(outputLine, "F", matcher.group(6));
20610 assertEquals(outputLine, "T", matcher.group(7));
20611 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20612 assertEquals(outputLine, "T", matcher.group(9));
20613
20614 assertTrue(GrouperClientWs.mostRecentRequest,
20615 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20616 assertTrue(GrouperClientWs.mostRecentRequest,
20617 !GrouperClientWs.mostRecentRequest.contains("actions"));
20618 assertTrue(GrouperClientWs.mostRecentRequest,
20619 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20620 assertTrue(GrouperClientWs.mostRecentRequest,
20621 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20622 assertTrue(GrouperClientWs.mostRecentRequest,
20623 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20624 assertTrue(GrouperClientWs.mostRecentRequest,
20625 GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20626 assertTrue(GrouperClientWs.mostRecentRequest,
20627 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20628 assertTrue(GrouperClientWs.mostRecentRequest,
20629 GrouperClientWs.mostRecentRequest.contains("permissionType"));
20630 assertTrue(GrouperClientWs.mostRecentRequest,
20631 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20632 assertTrue(GrouperClientWs.mostRecentRequest,
20633 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20634 assertTrue(GrouperClientWs.mostRecentRequest,
20635 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20636 assertTrue(GrouperClientWs.mostRecentRequest,
20637 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20638 assertTrue(GrouperClientWs.mostRecentRequest,
20639 !GrouperClientWs.mostRecentRequest.contains("params"));
20640 assertTrue(GrouperClientWs.mostRecentRequest,
20641 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20642 assertTrue(GrouperClientWs.mostRecentRequest,
20643 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20644 assertTrue(GrouperClientWs.mostRecentRequest,
20645 GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20646 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20647 assertTrue(GrouperClientWs.mostRecentRequest,
20648 !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20649 && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20650 assertTrue(GrouperClientWs.mostRecentRequest,
20651 GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups")
20652 && GrouperClientWs.mostRecentRequest.contains(group1.getName())
20653 && GrouperClientWs.mostRecentRequest.contains(member.getSubjectId()));
20654
20655
20656 } finally {
20657 System.setOut(systemOut);
20658 }
20659
20660 }
20661
20662
20663
20664
20665
20666 public void atestGetGroupsCache() throws Exception {
20667
20668
20669 GrouperSession grouperSession = GrouperSession.startRootSession();
20670 Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
20671 "aStem:aGroup", "aGroup", "description1", null, true);
20672
20673 String wsUserLabel = GrouperClientUtils.propertiesValue(
20674 "grouperClient.webService.user.label", true);
20675 String wsUserString = GrouperClientUtils.propertiesValue(
20676 "grouperClient.webService." + wsUserLabel, true);
20677 Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
20678
20679 group.grantPriv(wsUser, AccessPrivilege.READ, false);
20680 group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
20681
20682
20683 group.addMember(SubjectTestHelper.SUBJ0, false);
20684
20685 WsGetGroupsResults wsGetGroupsResults = new GcGetGroups().addSubjectId(SubjectTestHelper.SUBJ0_ID).execute();
20686
20687 assertEquals("description1", wsGetGroupsResults.getResults()[0].getWsGroups()[0].getDescription());
20688
20689
20690 WsGroupToSave wsGroupToSave = new WsGroupToSave();
20691 wsGroupToSave.setWsGroupLookup(new WsGroupLookup("aStem:aGroup", null));
20692 WsGroup wsGroup = new WsGroup();
20693 wsGroup.setDescription("description2");
20694 wsGroup.setName("aStem:aGroup");
20695 wsGroup.setDisplayExtension("aGroup");
20696 wsGroupToSave.setWsGroup(wsGroup);
20697 WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
20698 assertEquals("description2", wsGroupSaveResults.getResults()[0].getWsGroup().getDescription());
20699
20700
20701 wsGetGroupsResults = new GcGetGroups().addSubjectId(SubjectTestHelper.SUBJ0_ID).execute();
20702
20703 assertEquals("description2", wsGetGroupsResults.getResults()[0].getWsGroups()[0].getDescription());
20704
20705
20706 }
20707
20708
20709
20710
20711 public void testAttributeDefNameSave() throws Exception {
20712
20713 PrintStream systemOut = System.out;
20714
20715 ByteArrayOutputStream baos = new ByteArrayOutputStream();
20716 System.setOut(new PrintStream(baos));
20717 String output = null;
20718 String[] outputLines = null;
20719 Pattern pattern = null;
20720 Matcher matcher = null;
20721 try {
20722
20723 GrouperSession grouperSession = GrouperSession.startRootSession();
20724
20725 AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem:newAttributeDef")
20726 .assignCreateParentStemsIfNotExist(true).save();
20727
20728 GrouperClient.main(GrouperClientUtils.splitTrim(
20729 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --nameOfAttributeDef=aStem:newAttributeDef", " "));
20730 System.out.flush();
20731 output = new String(baos.toByteArray());
20732
20733 systemOut.println(output);
20734
20735 System.setOut(systemOut);
20736
20737 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20738
20739 assertEquals(1, outputLines.length);
20740
20741 pattern = Pattern.compile("^Success: (T|F): code: ([A-Z_]+): (.*+)$");
20742 matcher = pattern.matcher(outputLines[0]);
20743
20744 assertTrue(outputLines[0], matcher.matches());
20745
20746 assertEquals(outputLines[0], "T", matcher.group(1));
20747 assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
20748 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20749
20750
20751
20752
20753 baos = new ByteArrayOutputStream();
20754 System.setOut(new PrintStream(baos));
20755
20756 GrouperClient.main(GrouperClientUtils.splitTrim(
20757 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName0/1 --nameOfAttributeDef=aStem:newAttributeDef", " "));
20758 System.out.flush();
20759 output = new String(baos.toByteArray());
20760
20761 System.setOut(systemOut);
20762
20763 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20764
20765 assertEquals(1, outputLines.length);
20766
20767 matcher = pattern.matcher(outputLines[0]);
20768
20769 assertTrue(outputLines[0], matcher.matches());
20770
20771 assertEquals(outputLines[0], "T", matcher.group(1));
20772 assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
20773 assertEquals(outputLines[0], "aStem:newAttributeDefName0/1", matcher.group(3));
20774
20775 assertFalse(GrouperClientWs.mostRecentRequest,
20776 GrouperClientWs.mostRecentRequest.contains("saveMode"));
20777
20778
20779
20780
20781 baos = new ByteArrayOutputStream();
20782 System.setOut(new PrintStream(baos));
20783
20784 GrouperClient.main(GrouperClientUtils.splitTrim(
20785 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName0/1 --nameOfAttributeDef=aStem:newAttributeDef --saveMode=UPDATE", " "));
20786 System.out.flush();
20787 output = new String(baos.toByteArray());
20788
20789 System.setOut(systemOut);
20790
20791 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20792
20793 assertEquals(1, outputLines.length);
20794
20795 matcher = pattern.matcher(outputLines[0]);
20796
20797 assertTrue(outputLines[0], matcher.matches());
20798
20799 assertEquals(outputLines[0], "T", matcher.group(1));
20800 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20801 assertEquals(outputLines[0], "aStem:newAttributeDefName0/1", matcher.group(3));
20802
20803 assertTrue(GrouperClientWs.mostRecentRequest,
20804 GrouperClientWs.mostRecentRequest.contains("saveMode")
20805 && GrouperClientWs.mostRecentRequest.contains(">UPDATE<"));
20806 assertFalse(GrouperClientWs.mostRecentRequest,
20807 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup"));
20808
20809
20810
20811
20812 baos = new ByteArrayOutputStream();
20813 System.setOut(new PrintStream(baos));
20814
20815 GrouperClient.main(GrouperClientUtils.splitTrim(
20816 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --attributeDefNameLookupName=aStem:newAttributeDefName --nameOfAttributeDef=aStem:newAttributeDef", " "));
20817 System.out.flush();
20818 output = new String(baos.toByteArray());
20819
20820 System.setOut(systemOut);
20821
20822 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20823
20824 assertEquals(1, outputLines.length);
20825
20826 matcher = pattern.matcher(outputLines[0]);
20827
20828 assertTrue(outputLines[0], matcher.matches());
20829
20830 assertEquals(outputLines[0], "T", matcher.group(1));
20831 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20832 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20833
20834 assertFalse(GrouperClientWs.mostRecentRequest,
20835 GrouperClientWs.mostRecentRequest.contains("saveMode"));
20836 assertTrue(GrouperClientWs.mostRecentRequest,
20837 GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefNameLookup>"));
20838
20839
20840
20841
20842
20843 AttributeDefName newAttributeDefName = AttributeDefNameFinder.findByName("aStem:newAttributeDefName", true);
20844
20845 baos = new ByteArrayOutputStream();
20846 System.setOut(new PrintStream(baos));
20847
20848 GrouperClient.main(GrouperClientUtils.splitTrim(
20849 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --attributeDefNameLookupUuid=" + newAttributeDefName.getId() + " --nameOfAttributeDef=aStem:newAttributeDef", " "));
20850 System.out.flush();
20851 output = new String(baos.toByteArray());
20852
20853 System.setOut(systemOut);
20854
20855 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20856
20857 assertEquals(1, outputLines.length);
20858
20859 matcher = pattern.matcher(outputLines[0]);
20860
20861 assertTrue(outputLines[0], matcher.matches());
20862
20863 assertEquals(outputLines[0], "T", matcher.group(1));
20864 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20865 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20866
20867 assertFalse(GrouperClientWs.mostRecentRequest,
20868 GrouperClientWs.mostRecentRequest.contains("description"));
20869 assertTrue(GrouperClientWs.mostRecentRequest,
20870 GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefNameLookup>")
20871 && GrouperClientWs.mostRecentRequest.contains(newAttributeDefName.getId()));
20872
20873
20874
20875
20876 baos = new ByteArrayOutputStream();
20877 System.setOut(new PrintStream(baos));
20878
20879 GrouperClient.main(GrouperClientUtils.splitTrim(
20880 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --attributeDefNameLookupIdIndex=" + newAttributeDefName.getIdIndex() + " --nameOfAttributeDef=aStem:newAttributeDef", " "));
20881 System.out.flush();
20882 output = new String(baos.toByteArray());
20883
20884 System.setOut(systemOut);
20885
20886 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20887
20888 assertEquals(1, outputLines.length);
20889
20890 matcher = pattern.matcher(outputLines[0]);
20891
20892 assertTrue(outputLines[0], matcher.matches());
20893
20894 assertEquals(outputLines[0], "T", matcher.group(1));
20895 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20896 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20897
20898 assertFalse(GrouperClientWs.mostRecentRequest,
20899 GrouperClientWs.mostRecentRequest.contains("description"));
20900 assertTrue(GrouperClientWs.mostRecentRequest,
20901 GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefNameLookup>")
20902 && GrouperClientWs.mostRecentRequest.contains(newAttributeDefName.getIdIndex().toString()));
20903
20904
20905
20906
20907 baos = new ByteArrayOutputStream();
20908 System.setOut(new PrintStream(baos));
20909
20910 GrouperClient.main(GrouperClientUtils.splitTrim(
20911 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --description=theDescription --nameOfAttributeDef=aStem:newAttributeDef", " "));
20912 System.out.flush();
20913 output = new String(baos.toByteArray());
20914
20915 System.setOut(systemOut);
20916
20917 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20918
20919 assertEquals(1, outputLines.length);
20920
20921 matcher = pattern.matcher(outputLines[0]);
20922
20923 assertTrue(outputLines[0], matcher.matches());
20924
20925 assertEquals(outputLines[0], "T", matcher.group(1));
20926 assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
20927 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20928
20929 assertTrue(GrouperClientWs.mostRecentRequest,
20930 GrouperClientWs.mostRecentRequest.contains("<description>")
20931 && GrouperClientWs.mostRecentRequest.contains("theDescription"));
20932
20933
20934
20935
20936 baos = new ByteArrayOutputStream();
20937 System.setOut(new PrintStream(baos));
20938
20939 GrouperClient.main(GrouperClientUtils.splitTrim(
20940 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName5 --idIndex=12345 --nameOfAttributeDef=aStem:newAttributeDef", " "));
20941 System.out.flush();
20942 output = new String(baos.toByteArray());
20943
20944 System.setOut(systemOut);
20945
20946 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20947
20948 assertEquals(1, outputLines.length);
20949
20950 matcher = pattern.matcher(outputLines[0]);
20951
20952 assertTrue(outputLines[0], matcher.matches());
20953
20954 assertEquals(outputLines[0], "T", matcher.group(1));
20955 assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
20956 assertEquals(outputLines[0], "aStem:newAttributeDefName5", matcher.group(3));
20957
20958 assertTrue(GrouperClientWs.mostRecentRequest,
20959 GrouperClientWs.mostRecentRequest.contains("<idIndex>")
20960 && GrouperClientWs.mostRecentRequest.contains("12345"));
20961 assertTrue(GrouperClientWs.mostRecentResponse,
20962 GrouperClientWs.mostRecentResponse.contains("<idIndex>12345"));
20963
20964
20965
20966
20967 baos = new ByteArrayOutputStream();
20968 System.setOut(new PrintStream(baos));
20969
20970 GrouperClient.main(GrouperClientUtils.splitTrim(
20971 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --displayExtension=theDisplayExtension --nameOfAttributeDef=aStem:newAttributeDef", " "));
20972 System.out.flush();
20973 output = new String(baos.toByteArray());
20974
20975 System.setOut(systemOut);
20976
20977 outputLines = GrouperClientUtils.splitTrim(output, "\n");
20978
20979 assertEquals(1, outputLines.length);
20980
20981 matcher = pattern.matcher(outputLines[0]);
20982
20983 assertTrue(outputLines[0], matcher.matches());
20984
20985 assertEquals(outputLines[0], "T", matcher.group(1));
20986 assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
20987 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20988
20989 assertFalse(GrouperClientWs.mostRecentRequest,
20990 GrouperClientWs.mostRecentRequest.contains("createParentStemsIfNotExist"));
20991 assertTrue(GrouperClientWs.mostRecentRequest,
20992 GrouperClientWs.mostRecentRequest.contains("<displayExtension>")
20993 && GrouperClientWs.mostRecentRequest.contains("theDisplayExtension"));
20994
20995
20996
20997
20998 baos = new ByteArrayOutputStream();
20999 System.setOut(new PrintStream(baos));
21000
21001 GrouperClient.main(GrouperClientUtils.splitTrim(
21002 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --createParentStemsIfNotExist=true --nameOfAttributeDef=aStem:newAttributeDef", " "));
21003 System.out.flush();
21004 output = new String(baos.toByteArray());
21005
21006 System.setOut(systemOut);
21007
21008 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21009
21010 assertEquals(1, outputLines.length);
21011
21012 matcher = pattern.matcher(outputLines[0]);
21013
21014 assertTrue(outputLines[0], matcher.matches());
21015
21016 assertEquals(outputLines[0], "T", matcher.group(1));
21017 assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
21018 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21019
21020 assertFalse(GrouperClientWs.mostRecentRequest,
21021 GrouperClientWs.mostRecentRequest.contains("attributeDefId"));
21022 assertTrue(GrouperClientWs.mostRecentRequest,
21023 GrouperClientWs.mostRecentRequest.contains("createParentStemsIfNotExist"));
21024 assertTrue(GrouperClientWs.mostRecentRequest,
21025 GrouperClientWs.mostRecentRequest.contains("<attributeDefName>"));
21026
21027
21028
21029
21030 baos = new ByteArrayOutputStream();
21031 System.setOut(new PrintStream(baos));
21032
21033 GrouperClient.main(GrouperClientUtils.splitTrim(
21034 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --uuidOfAttributeDef=" + attributeDef.getId(), " "));
21035 System.out.flush();
21036 output = new String(baos.toByteArray());
21037
21038 System.setOut(systemOut);
21039
21040 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21041
21042 assertEquals(1, outputLines.length);
21043
21044 matcher = pattern.matcher(outputLines[0]);
21045
21046 assertTrue(outputLines[0], matcher.matches());
21047
21048 assertEquals(outputLines[0], "T", matcher.group(1));
21049 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21050 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21051
21052 assertFalse(GrouperClientWs.mostRecentRequest,
21053 GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
21054 assertTrue(GrouperClientWs.mostRecentRequest,
21055 GrouperClientWs.mostRecentRequest.contains("<attributeDefId>"));
21056
21057
21058
21059
21060
21061 baos = new ByteArrayOutputStream();
21062 System.setOut(new PrintStream(baos));
21063
21064 GrouperClient.main(GrouperClientUtils.splitTrim(
21065 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --actAsSubjectId=GrouperSystem --nameOfAttributeDef=aStem:newAttributeDef", " "));
21066 System.out.flush();
21067 output = new String(baos.toByteArray());
21068
21069 System.setOut(systemOut);
21070
21071 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21072
21073 assertEquals(1, outputLines.length);
21074
21075 matcher = pattern.matcher(outputLines[0]);
21076
21077 assertTrue(outputLines[0], matcher.matches());
21078
21079 assertEquals(outputLines[0], "T", matcher.group(1));
21080 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21081 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21082
21083 assertFalse(GrouperClientWs.mostRecentRequest,
21084 GrouperClientWs.mostRecentRequest.contains("subjectIdentifier"));
21085 assertTrue(GrouperClientWs.mostRecentRequest,
21086 GrouperClientWs.mostRecentRequest.contains("<actAsSubjectLookup><subjectId>"));
21087
21088
21089
21090
21091
21092 baos = new ByteArrayOutputStream();
21093 System.setOut(new PrintStream(baos));
21094
21095 GrouperClient.main(GrouperClientUtils.splitTrim(
21096 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --actAsSubjectIdentifier=GrouperSystem --nameOfAttributeDef=aStem:newAttributeDef", " "));
21097 System.out.flush();
21098 output = new String(baos.toByteArray());
21099
21100 System.setOut(systemOut);
21101
21102 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21103
21104 assertEquals(1, outputLines.length);
21105
21106 matcher = pattern.matcher(outputLines[0]);
21107
21108 assertTrue(outputLines[0], matcher.matches());
21109
21110 assertEquals(outputLines[0], "T", matcher.group(1));
21111 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21112 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21113
21114 assertFalse(GrouperClientWs.mostRecentRequest,
21115 GrouperClientWs.mostRecentRequest.contains("sourceId"));
21116 assertTrue(GrouperClientWs.mostRecentRequest,
21117 GrouperClientWs.mostRecentRequest.contains("<actAsSubjectLookup><subjectIdentifier>"));
21118
21119
21120
21121
21122
21123 baos = new ByteArrayOutputStream();
21124 System.setOut(new PrintStream(baos));
21125
21126 GrouperClient.main(GrouperClientUtils.splitTrim(
21127 "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --actAsSubjectIdentifier=GrouperSystem --actAsSubjectSource=g:isa --nameOfAttributeDef=aStem:newAttributeDef", " "));
21128 System.out.flush();
21129 output = new String(baos.toByteArray());
21130
21131 System.setOut(systemOut);
21132
21133 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21134
21135 assertEquals(1, outputLines.length);
21136
21137 matcher = pattern.matcher(outputLines[0]);
21138
21139 assertTrue(outputLines[0], matcher.matches());
21140
21141 assertEquals(outputLines[0], "T", matcher.group(1));
21142 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21143 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21144
21145 assertFalse(GrouperClientWs.mostRecentRequest,
21146 GrouperClientWs.mostRecentRequest.contains("somethingelse"));
21147 assertTrue(GrouperClientWs.mostRecentRequest,
21148 GrouperClientWs.mostRecentRequest.contains("subjectSourceId")
21149 && GrouperClientWs.mostRecentRequest.contains("g:isa"));
21150
21151 } finally {
21152 System.setOut(systemOut);
21153 }
21154
21155 }
21156
21157
21158
21159
21160 public void testAttributeDefNameDelete() throws Exception {
21161
21162 PrintStream systemOut = System.out;
21163
21164 ByteArrayOutputStream baos = new ByteArrayOutputStream();
21165 System.setOut(new PrintStream(baos));
21166 String output = null;
21167 String[] outputLines = null;
21168 Pattern pattern = null;
21169 Matcher matcher = null;
21170 try {
21171
21172 GrouperSession grouperSession = GrouperSession.startRootSession();
21173
21174 AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem:newAttributeDef")
21175 .assignCreateParentStemsIfNotExist(true).save();
21176
21177 AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName")
21178 .assignCreateParentStemsIfNotExist(true).save();
21179
21180 GrouperClient.main(GrouperClientUtils.splitTrim(
21181 "--operation=attributeDefNameDeleteWs --attributeDefNameNames=aStem:newAttributeDefName,aStem:newAttributeDefName2", " "));
21182 System.out.flush();
21183 output = new String(baos.toByteArray());
21184
21185 systemOut.println(output);
21186
21187 System.setOut(systemOut);
21188
21189 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21190
21191 assertEquals(2, outputLines.length);
21192
21193 pattern = Pattern.compile("^Index (\\d+): success: (T|F): code: ([A-Z_]+): (.*+)$");
21194 matcher = pattern.matcher(outputLines[0]);
21195
21196 assertTrue(outputLines[0], matcher.matches());
21197
21198 assertEquals(outputLines[0], "0", matcher.group(1));
21199 assertEquals(outputLines[0], "T", matcher.group(2));
21200 assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
21201 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(4));
21202
21203 matcher = pattern.matcher(outputLines[1]);
21204
21205 assertTrue(outputLines[1], matcher.matches());
21206
21207 assertEquals(outputLines[1], "1", matcher.group(1));
21208 assertEquals(outputLines[1], "T", matcher.group(2));
21209 assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NAME_NOT_FOUND", matcher.group(3));
21210 assertEquals(outputLines[1], "aStem:newAttributeDefName2", matcher.group(4));
21211
21212
21213
21214 baos = new ByteArrayOutputStream();
21215 System.setOut(new PrintStream(baos));
21216
21217 GrouperClient.main(GrouperClientUtils.splitTrim(
21218 "--operation=attributeDefNameDeleteWs --attributeDefNameNames=aStem:newAttributeDefName,aStem:newAttributeDefName2 --txType=READ_WRITE_NEW", " "));
21219 System.out.flush();
21220 output = new String(baos.toByteArray());
21221
21222 System.setOut(systemOut);
21223
21224 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21225
21226 assertEquals(2, outputLines.length);
21227
21228 matcher = pattern.matcher(outputLines[0]);
21229
21230 assertTrue(outputLines[0], matcher.matches());
21231
21232 assertEquals(outputLines[0], "0", matcher.group(1));
21233 assertEquals(outputLines[0], "T", matcher.group(2));
21234 assertEquals(outputLines[0], "SUCCESS_ATTRIBUTE_DEF_NAME_NOT_FOUND", matcher.group(3));
21235 assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(4));
21236
21237 matcher = pattern.matcher(outputLines[1]);
21238
21239 assertTrue(outputLines[1], matcher.matches());
21240
21241 assertEquals(outputLines[1], "1", matcher.group(1));
21242 assertEquals(outputLines[1], "T", matcher.group(2));
21243 assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NAME_NOT_FOUND", matcher.group(3));
21244 assertEquals(outputLines[1], "aStem:newAttributeDefName2", matcher.group(4));
21245
21246 assertTrue(GrouperClientWs.mostRecentRequest,
21247 GrouperClientWs.mostRecentRequest.contains("txType") && GrouperClientWs.mostRecentRequest.contains("READ_WRITE_NEW"));
21248
21249
21250 } finally {
21251 System.setOut(systemOut);
21252 }
21253
21254 }
21255
21256
21257
21258
21259 public void testFindAttributeDefNames() throws Exception {
21260
21261 PrintStream systemOut = System.out;
21262
21263 ByteArrayOutputStream baos = new ByteArrayOutputStream();
21264 System.setOut(new PrintStream(baos));
21265 String output = null;
21266 String[] outputLines = null;
21267 Pattern pattern = null;
21268 Matcher matcher = null;
21269 try {
21270
21271 GrouperSession grouperSession = GrouperSession.startRootSession();
21272
21273 AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem1:newAttributeDef")
21274 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.perm).assignToGroup(true).save();
21275
21276 AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem1:newAttributeDefName1")
21277 .assignCreateParentStemsIfNotExist(true).save();
21278
21279 AttributeDefName attributeDefName2 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem1:newAttributeDefName2")
21280 .assignCreateParentStemsIfNotExist(true).save();
21281
21282 attributeDefName.getAttributeDefNameSetDelegate().addToAttributeDefNameSet(attributeDefName2);
21283
21284 AttributeDefName attributeDefName3 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem1:sub:newAttributeDefName3")
21285 .assignCreateParentStemsIfNotExist(true).save();
21286
21287 AttributeDefName attributeDefName4 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem2:newAttributeDefName4")
21288 .assignCreateParentStemsIfNotExist(true).save();
21289
21290 GrouperClient.main(GrouperClientUtils.splitTrim(
21291 "--operation=findAttributeDefNamesWs --scope=aStem", " "));
21292 System.out.flush();
21293 output = new String(baos.toByteArray());
21294
21295 systemOut.println(output);
21296
21297 System.setOut(systemOut);
21298
21299 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21300
21301 assertEquals(4, outputLines.length);
21302
21303
21304 pattern = Pattern.compile("^Index (\\d+): name: (.*), displayName: (.*)$");
21305 matcher = pattern.matcher(outputLines[0]);
21306
21307 assertTrue(outputLines[0], matcher.matches());
21308
21309 assertEquals(outputLines[0], "0", matcher.group(1));
21310 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21311 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21312
21313 assertTrue(GrouperClientWs.mostRecentRequest,
21314 GrouperClientWs.mostRecentRequest.contains("scope"));
21315 assertFalse(GrouperClientWs.mostRecentRequest,
21316 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21317
21318
21319
21320 baos = new ByteArrayOutputStream();
21321
21322 System.setOut(new PrintStream(baos));
21323
21324 GrouperClient.main(GrouperClientUtils.splitTrim(
21325 "--operation=findAttributeDefNamesWs --scope=aStem --splitScope=T", " "));
21326 System.out.flush();
21327 output = new String(baos.toByteArray());
21328
21329 systemOut.println(output);
21330
21331 System.setOut(systemOut);
21332
21333 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21334
21335 assertEquals(4, outputLines.length);
21336
21337
21338 matcher = pattern.matcher(outputLines[0]);
21339
21340 assertTrue(outputLines[0], matcher.matches());
21341
21342 assertEquals(outputLines[0], "0", matcher.group(1));
21343 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21344 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21345
21346 assertTrue(GrouperClientWs.mostRecentRequest,
21347 GrouperClientWs.mostRecentRequest.contains("scope"));
21348 assertTrue(GrouperClientWs.mostRecentRequest,
21349 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21350 assertFalse(GrouperClientWs.mostRecentRequest,
21351 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21352
21353
21354
21355 baos = new ByteArrayOutputStream();
21356
21357 System.setOut(new PrintStream(baos));
21358
21359 GrouperClient.main(GrouperClientUtils.splitTrim(
21360 "--operation=findAttributeDefNamesWs --attributeDefNameNames=aStem1:newAttributeDefName1,aStem1:newAttributeDefName2", " "));
21361 System.out.flush();
21362 output = new String(baos.toByteArray());
21363
21364 systemOut.println(output);
21365
21366 System.setOut(systemOut);
21367
21368 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21369
21370 assertEquals(2, outputLines.length);
21371
21372
21373 matcher = pattern.matcher(outputLines[0]);
21374
21375 assertTrue(outputLines[0], matcher.matches());
21376
21377 assertEquals(outputLines[0], "0", matcher.group(1));
21378 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21379 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21380
21381 assertFalse(GrouperClientWs.mostRecentRequest,
21382 GrouperClientWs.mostRecentRequest.contains("scope"));
21383 assertFalse(GrouperClientWs.mostRecentRequest,
21384 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21385 assertTrue(GrouperClientWs.mostRecentRequest,
21386 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21387
21388
21389
21390 baos = new ByteArrayOutputStream();
21391
21392 System.setOut(new PrintStream(baos));
21393
21394 GrouperClient.main(GrouperClientUtils.splitTrim(
21395 "--operation=findAttributeDefNamesWs --attributeDefNameUuids=" + attributeDefName.getId() + "," + attributeDefName2.getId(), " "));
21396 System.out.flush();
21397 output = new String(baos.toByteArray());
21398
21399 systemOut.println(output);
21400
21401 System.setOut(systemOut);
21402
21403 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21404
21405 assertEquals(2, outputLines.length);
21406
21407
21408 matcher = pattern.matcher(outputLines[0]);
21409
21410 assertTrue(outputLines[0], matcher.matches());
21411
21412 assertEquals(outputLines[0], "0", matcher.group(1));
21413 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21414 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21415
21416 assertFalse(GrouperClientWs.mostRecentRequest,
21417 GrouperClientWs.mostRecentRequest.contains("scope"));
21418 assertFalse(GrouperClientWs.mostRecentRequest,
21419 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21420 assertTrue(GrouperClientWs.mostRecentRequest,
21421 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21422 assertFalse(GrouperClientWs.mostRecentRequest,
21423 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21424
21425
21426
21427 baos = new ByteArrayOutputStream();
21428
21429 System.setOut(new PrintStream(baos));
21430
21431 GrouperClient.main(GrouperClientUtils.splitTrim(
21432 "--operation=findAttributeDefNamesWs --attributeDefNameIdIndexes=" + attributeDefName.getIdIndex() + "," + attributeDefName2.getIdIndex(), " "));
21433 System.out.flush();
21434 output = new String(baos.toByteArray());
21435
21436 systemOut.println(output);
21437
21438 System.setOut(systemOut);
21439
21440 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21441
21442 assertEquals(2, outputLines.length);
21443
21444
21445 matcher = pattern.matcher(outputLines[0]);
21446
21447 assertTrue(outputLines[0], matcher.matches());
21448
21449 assertEquals(outputLines[0], "0", matcher.group(1));
21450 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21451 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21452
21453 assertFalse(GrouperClientWs.mostRecentRequest,
21454 GrouperClientWs.mostRecentRequest.contains("scope"));
21455 assertFalse(GrouperClientWs.mostRecentRequest,
21456 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21457 assertTrue(GrouperClientWs.mostRecentRequest,
21458 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21459 assertFalse(GrouperClientWs.mostRecentRequest,
21460 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21461
21462
21463
21464 baos = new ByteArrayOutputStream();
21465
21466 System.setOut(new PrintStream(baos));
21467
21468 GrouperClient.main(GrouperClientUtils.splitTrim(
21469 "--operation=findAttributeDefNamesWs --scope=% --nameOfAttributeDef=aStem1:newAttributeDef", " "));
21470 System.out.flush();
21471 output = new String(baos.toByteArray());
21472
21473 systemOut.println(output);
21474
21475 System.setOut(systemOut);
21476
21477 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21478
21479 assertEquals(4, outputLines.length);
21480
21481
21482 matcher = pattern.matcher(outputLines[0]);
21483
21484 assertTrue(outputLines[0], matcher.matches());
21485
21486 assertEquals(outputLines[0], "0", matcher.group(1));
21487 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21488 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21489
21490 assertTrue(GrouperClientWs.mostRecentRequest,
21491 GrouperClientWs.mostRecentRequest.contains("scope"));
21492 assertFalse(GrouperClientWs.mostRecentRequest,
21493 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21494 assertTrue(GrouperClientWs.mostRecentRequest,
21495 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21496
21497
21498
21499 baos = new ByteArrayOutputStream();
21500
21501 System.setOut(new PrintStream(baos));
21502
21503 GrouperClient.main(GrouperClientUtils.splitTrim(
21504 "--operation=findAttributeDefNamesWs --scope=% --uuidOfAttributeDef=" + attributeDef.getId(), " "));
21505 System.out.flush();
21506 output = new String(baos.toByteArray());
21507
21508 systemOut.println(output);
21509
21510 System.setOut(systemOut);
21511
21512 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21513
21514 assertEquals(4, outputLines.length);
21515
21516
21517 matcher = pattern.matcher(outputLines[0]);
21518
21519 assertTrue(outputLines[0], matcher.matches());
21520
21521 assertEquals(outputLines[0], "0", matcher.group(1));
21522 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21523 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21524
21525 assertTrue(GrouperClientWs.mostRecentRequest,
21526 GrouperClientWs.mostRecentRequest.contains("scope"));
21527 assertFalse(GrouperClientWs.mostRecentRequest,
21528 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21529 assertFalse(GrouperClientWs.mostRecentRequest,
21530 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21531 assertTrue(GrouperClientWs.mostRecentRequest,
21532 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21533
21534
21535
21536 baos = new ByteArrayOutputStream();
21537
21538 System.setOut(new PrintStream(baos));
21539
21540 GrouperClient.main(GrouperClientUtils.splitTrim(
21541 "--operation=findAttributeDefNamesWs --scope=% --idIndexOfAttributeDef=" + attributeDef.getIdIndex(), " "));
21542 System.out.flush();
21543 output = new String(baos.toByteArray());
21544
21545 systemOut.println(output);
21546
21547 System.setOut(systemOut);
21548
21549 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21550
21551 assertEquals(4, outputLines.length);
21552
21553
21554 matcher = pattern.matcher(outputLines[0]);
21555
21556 assertTrue(outputLines[0], matcher.matches());
21557
21558 assertEquals(outputLines[0], "0", matcher.group(1));
21559 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21560 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21561
21562 assertTrue(GrouperClientWs.mostRecentRequest,
21563 GrouperClientWs.mostRecentRequest.contains("scope"));
21564 assertFalse(GrouperClientWs.mostRecentRequest,
21565 GrouperClientWs.mostRecentRequest.contains("splitScope"));
21566 assertFalse(GrouperClientWs.mostRecentRequest,
21567 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21568 assertTrue(GrouperClientWs.mostRecentRequest,
21569 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21570
21571
21572
21573 baos = new ByteArrayOutputStream();
21574
21575 System.setOut(new PrintStream(baos));
21576
21577 GrouperClient.main(GrouperClientUtils.splitTrim(
21578 "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeAssignType=stem", " "));
21579 System.out.flush();
21580 output = new String(baos.toByteArray());
21581
21582 systemOut.println(output);
21583
21584 System.setOut(systemOut);
21585
21586 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21587
21588 assertEquals(0, GrouperUtil.length(outputLines));
21589
21590 assertTrue(GrouperClientWs.mostRecentRequest,
21591 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21592
21593
21594
21595 baos = new ByteArrayOutputStream();
21596
21597 System.setOut(new PrintStream(baos));
21598
21599 GrouperClient.main(GrouperClientUtils.splitTrim(
21600 "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeAssignType=group", " "));
21601 System.out.flush();
21602 output = new String(baos.toByteArray());
21603
21604 systemOut.println(output);
21605
21606 System.setOut(systemOut);
21607
21608 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21609
21610 assertEquals(3, outputLines.length);
21611
21612
21613 matcher = pattern.matcher(outputLines[0]);
21614
21615 assertTrue(outputLines[0], matcher.matches());
21616
21617 assertEquals(outputLines[0], "0", matcher.group(1));
21618 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21619 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21620
21621 assertTrue(GrouperClientWs.mostRecentRequest,
21622 GrouperClientWs.mostRecentRequest.contains("scope"));
21623 assertTrue(GrouperClientWs.mostRecentRequest,
21624 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21625
21626
21627
21628 baos = new ByteArrayOutputStream();
21629
21630 System.setOut(new PrintStream(baos));
21631
21632 GrouperClient.main(GrouperClientUtils.splitTrim(
21633 "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeDefType=attr", " "));
21634 System.out.flush();
21635 output = new String(baos.toByteArray());
21636
21637 systemOut.println(output);
21638
21639 System.setOut(systemOut);
21640
21641 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21642
21643 assertEquals(0, GrouperUtil.length(outputLines));
21644
21645 assertTrue(GrouperClientWs.mostRecentRequest,
21646 GrouperClientWs.mostRecentRequest.contains("scope"));
21647 assertFalse(GrouperClientWs.mostRecentRequest,
21648 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21649 assertTrue(GrouperClientWs.mostRecentRequest,
21650 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
21651
21652
21653
21654 baos = new ByteArrayOutputStream();
21655
21656 System.setOut(new PrintStream(baos));
21657
21658 GrouperClient.main(GrouperClientUtils.splitTrim(
21659 "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeDefType=perm", " "));
21660 System.out.flush();
21661 output = new String(baos.toByteArray());
21662
21663 systemOut.println(output);
21664
21665 System.setOut(systemOut);
21666
21667 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21668
21669 assertEquals(3, outputLines.length);
21670
21671
21672 matcher = pattern.matcher(outputLines[0]);
21673
21674 assertTrue(outputLines[0], matcher.matches());
21675
21676 assertEquals(outputLines[0], "0", matcher.group(1));
21677 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21678 assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21679
21680 assertTrue(GrouperClientWs.mostRecentRequest,
21681 GrouperClientWs.mostRecentRequest.contains("scope"));
21682 assertFalse(GrouperClientWs.mostRecentRequest,
21683 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21684 assertTrue(GrouperClientWs.mostRecentRequest,
21685 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
21686 assertFalse(GrouperClientWs.mostRecentRequest,
21687 GrouperClientWs.mostRecentRequest.contains("wsInheritanceSetRelation"));
21688
21689
21690
21691 baos = new ByteArrayOutputStream();
21692
21693 System.setOut(new PrintStream(baos));
21694
21695 GrouperClient.main(GrouperClientUtils.splitTrim(
21696 "--operation=findAttributeDefNamesWs --attributeDefNameNames=aStem1:newAttributeDefName1 --inheritanceSetRelation=IMPLIED_BY_THIS", " "));
21697 System.out.flush();
21698 output = new String(baos.toByteArray());
21699
21700 systemOut.println(output);
21701
21702 System.setOut(systemOut);
21703
21704 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21705
21706 assertEquals(1, outputLines.length);
21707
21708
21709 matcher = pattern.matcher(outputLines[0]);
21710
21711 assertTrue(outputLines[0], matcher.matches());
21712
21713 assertEquals(outputLines[0], "0", matcher.group(1));
21714 assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(2));
21715 assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(3));
21716
21717 assertTrue(GrouperClientWs.mostRecentRequest,
21718 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21719 assertTrue(GrouperClientWs.mostRecentRequest,
21720 GrouperClientWs.mostRecentRequest.contains("wsInheritanceSetRelation"));
21721 assertFalse(GrouperClientWs.mostRecentRequest,
21722 GrouperClientWs.mostRecentRequest.contains("sortString"));
21723 assertFalse(GrouperClientWs.mostRecentRequest,
21724 GrouperClientWs.mostRecentRequest.contains("ascending"));
21725 assertFalse(GrouperClientWs.mostRecentRequest,
21726 GrouperClientWs.mostRecentRequest.contains("pageNumber"));
21727 assertFalse(GrouperClientWs.mostRecentRequest,
21728 GrouperClientWs.mostRecentRequest.contains("pageSize"));
21729
21730
21731
21732
21733 baos = new ByteArrayOutputStream();
21734
21735 System.setOut(new PrintStream(baos));
21736
21737 GrouperClient.main(GrouperClientUtils.splitTrim(
21738 "--operation=findAttributeDefNamesWs --scope=aStem --sortString=extension --ascending=F --pageNumber=2 --pageSize=2", " "));
21739 System.out.flush();
21740 output = new String(baos.toByteArray());
21741
21742 systemOut.println(output);
21743
21744 System.setOut(systemOut);
21745
21746 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21747
21748 assertEquals(2, outputLines.length);
21749
21750
21751 matcher = pattern.matcher(outputLines[0]);
21752
21753 assertTrue(outputLines[0], matcher.matches());
21754
21755 assertEquals(outputLines[0], "0", matcher.group(1));
21756 assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(2));
21757 assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(3));
21758
21759 assertFalse(GrouperClientWs.mostRecentRequest,
21760 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21761 assertFalse(GrouperClientWs.mostRecentRequest,
21762 GrouperClientWs.mostRecentRequest.contains("wsInheritanceSetRelation"));
21763 assertTrue(GrouperClientWs.mostRecentRequest,
21764 GrouperClientWs.mostRecentRequest.contains("sortString"));
21765 assertTrue(GrouperClientWs.mostRecentRequest,
21766 GrouperClientWs.mostRecentRequest.contains("ascending"));
21767 assertTrue(GrouperClientWs.mostRecentRequest,
21768 GrouperClientWs.mostRecentRequest.contains("pageNumber"));
21769 assertTrue(GrouperClientWs.mostRecentRequest,
21770 GrouperClientWs.mostRecentRequest.contains("pageSize"));
21771
21772
21773 } finally {
21774 System.setOut(systemOut);
21775 }
21776
21777 }
21778
21779
21780
21781
21782 public void testAssignAttributeDefNameInheritanceWs() throws Exception {
21783
21784 PrintStream systemOut = System.out;
21785
21786 ByteArrayOutputStream baos = new ByteArrayOutputStream();
21787 System.setOut(new PrintStream(baos));
21788 String output = null;
21789 String[] outputLines = null;
21790 Pattern pattern = null;
21791 Matcher matcher = null;
21792 try {
21793
21794 GrouperSession grouperSession = GrouperSession.startRootSession();
21795
21796 AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem:newAttributeDef")
21797 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.perm).save();
21798
21799 AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName")
21800 .assignCreateParentStemsIfNotExist(true).save();
21801
21802 AttributeDefName attributeDefName2 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName2")
21803 .assignCreateParentStemsIfNotExist(true).save();
21804
21805 AttributeDefName attributeDefName3 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName3")
21806 .assignCreateParentStemsIfNotExist(true).save();
21807
21808 GrouperClient.main(GrouperClientUtils.splitTrim(
21809 "--operation=assignAttributeDefNameInheritanceWs --attributeDefNameName=aStem:newAttributeDefName --relatedAttributeDefNameNames=aStem:newAttributeDefName2,aStem:newAttributeDefName3 --assign=T", " "));
21810 System.out.flush();
21811 output = new String(baos.toByteArray());
21812
21813 systemOut.println(output);
21814
21815 System.setOut(systemOut);
21816
21817 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21818
21819 assertEquals(1, outputLines.length);
21820
21821
21822 pattern = Pattern.compile("^Success: (T|F): code: ([A-Z_]+), message: (.*+)$");
21823 matcher = pattern.matcher(outputLines[0]);
21824
21825 assertTrue(outputLines[0], matcher.matches());
21826
21827 assertEquals(outputLines[0], "T", matcher.group(1));
21828 assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
21829
21830 assertTrue(outputLines[0], matcher.group(3).contains("Had 2 successful adds"));
21831
21832
21833
21834 baos = new ByteArrayOutputStream();
21835
21836 System.setOut(new PrintStream(baos));
21837
21838 GrouperClient.main(GrouperClientUtils.splitTrim(
21839 "--operation=assignAttributeDefNameInheritanceWs --attributeDefNameName=aStem:newAttributeDefName " +
21840 "--relatedAttributeDefNameNames=aStem:newAttributeDefName2,aStem:newAttributeDefName3 --assign=T --replaceAllExisting=T", " "));
21841 System.out.flush();
21842 output = new String(baos.toByteArray());
21843
21844 systemOut.println(output);
21845
21846 System.setOut(systemOut);
21847
21848 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21849
21850 assertEquals(1, outputLines.length);
21851
21852 matcher = pattern.matcher(outputLines[0]);
21853
21854 assertTrue(outputLines[0], matcher.matches());
21855
21856 assertEquals(outputLines[0], "T", matcher.group(1));
21857 assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
21858
21859 assertTrue(outputLines[0], matcher.group(3).contains("2 adds which already existed"));
21860
21861
21862
21863
21864 baos = new ByteArrayOutputStream();
21865
21866 System.setOut(new PrintStream(baos));
21867
21868 GrouperClient.main(GrouperClientUtils.splitTrim(
21869 "--operation=assignAttributeDefNameInheritanceWs --attributeDefNameName=aStem:newAttributeDefName " +
21870 "--relatedAttributeDefNameNames=aStem:newAttributeDefName2,aStem:newAttributeDefName3 --assign=F --txType=READ_WRITE_NEW", " "));
21871 System.out.flush();
21872 output = new String(baos.toByteArray());
21873
21874 systemOut.println(output);
21875
21876 System.setOut(systemOut);
21877
21878 outputLines = GrouperClientUtils.splitTrim(output, "\n");
21879
21880 assertEquals(1, outputLines.length);
21881
21882 matcher = pattern.matcher(outputLines[0]);
21883
21884 assertTrue(outputLines[0], matcher.matches());
21885
21886 assertEquals(outputLines[0], "T", matcher.group(1));
21887 assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
21888
21889 assertTrue(outputLines[0], matcher.group(3).contains("2 successful removes"));
21890
21891 assertTrue(GrouperClientWs.mostRecentRequest,
21892 GrouperClientWs.mostRecentRequest.contains("txType") && GrouperClientWs.mostRecentRequest.contains("READ_WRITE_NEW"));
21893
21894
21895
21896 } finally {
21897 System.setOut(systemOut);
21898 }
21899
21900 }
21901
21902
21903
21904
21905 public void testGetAttributeAssignsGroupExtraFeatures() throws Exception {
21906
21907 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
21908 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
21909
21910 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
21911
21912 attributeDef.setValueType(AttributeDefValueType.string);
21913 attributeDef.store();
21914
21915 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
21916
21917 attributeDef2.setAssignToGroup(false);
21918 attributeDef2.setAssignToGroupAssn(true);
21919 attributeDef2.setValueType(AttributeDefValueType.integer);
21920 attributeDef2.store();
21921
21922 Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
21923 .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
21924 .assignDescription("description").save();
21925
21926
21927 group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
21928 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
21929
21930
21931 attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
21932
21933 AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
21934 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
21935 attributeAssign.getValueDelegate().assignValue("abc");
21936
21937 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
21938 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
21939 attributeAssign2.getValueDelegate().assignValue("123");
21940
21941 PrintStream systemOut = System.out;
21942
21943 ByteArrayOutputStream baos = new ByteArrayOutputStream();
21944 System.setOut(new PrintStream(baos));
21945
21946 try {
21947
21948 GrouperClient.main(GrouperClientUtils.splitTrim(
21949 "--operation=getAttributeAssignmentsWs --attributeAssignType=group " +
21950 "--attributeDefNames=test:testAttributeAssignDefNameDef " +
21951 "--attributeDefValueType=string --value=abc",
21952 " "));
21953 System.out.flush();
21954 String output = new String(baos.toByteArray());
21955
21956 System.setOut(systemOut);
21957
21958 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
21959
21960
21961
21962 Pattern pattern = Pattern
21963 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
21964
21965 assertEquals(1, GrouperUtil.length(outputLines));
21966 String outputLine = outputLines[0];
21967
21968 Matcher matcher = pattern.matcher(outputLines[0]);
21969
21970 assertTrue(outputLine, matcher.matches());
21971 assertEquals(outputLine, "0", matcher.group(1));
21972 assertEquals(outputLine, "group", matcher.group(2));
21973 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
21974 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
21975 assertEquals(outputLine, "assign", matcher.group(5));
21976 assertEquals(outputLine, "abc", matcher.group(6));
21977 assertEquals(outputLine, "T", matcher.group(7));
21978 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
21979
21980 assertTrue(GrouperClientWs.mostRecentRequest,
21981 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
21982 assertTrue(GrouperClientWs.mostRecentRequest,
21983 !GrouperClientWs.mostRecentRequest.contains("actions"));
21984 assertTrue(GrouperClientWs.mostRecentRequest,
21985 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21986 assertTrue(GrouperClientWs.mostRecentRequest,
21987 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
21988 assertTrue(GrouperClientWs.mostRecentRequest,
21989 !GrouperClientWs.mostRecentRequest.contains("enabled"));
21990 assertTrue(GrouperClientWs.mostRecentRequest,
21991 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
21992 assertTrue(GrouperClientWs.mostRecentRequest,
21993 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
21994 assertTrue(GrouperClientWs.mostRecentRequest,
21995 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
21996 assertTrue(GrouperClientWs.mostRecentRequest,
21997 !GrouperClientWs.mostRecentRequest.contains("params"));
21998 assertTrue(GrouperClientWs.mostRecentRequest,
21999 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22000 assertTrue(GrouperClientWs.mostRecentRequest,
22001 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22002 assertTrue(GrouperClientWs.mostRecentRequest,
22003 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
22004 assertTrue(GrouperClientWs.mostRecentRequest,
22005 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22006 assertTrue(GrouperClientWs.mostRecentRequest,
22007 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22008 assertTrue(GrouperClientWs.mostRecentRequest,
22009 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22010 assertTrue(GrouperClientWs.mostRecentRequest,
22011 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22012 assertTrue(GrouperClientWs.mostRecentRequest,
22013 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22014 assertTrue(GrouperClientWs.mostRecentRequest,
22015 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22016 assertTrue(GrouperClientWs.mostRecentRequest,
22017 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22018 assertTrue(GrouperClientWs.mostRecentRequest,
22019 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22020 assertTrue(GrouperClientWs.mostRecentRequest,
22021 GrouperClientWs.mostRecentRequest.contains("theValue"));
22022 assertTrue(GrouperClientWs.mostRecentRequest,
22023 GrouperClientWs.mostRecentRequest.contains("abc"));
22024 assertTrue(GrouperClientWs.mostRecentRequest,
22025 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22026 assertTrue(GrouperClientWs.mostRecentRequest,
22027 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22028 assertTrue(GrouperClientWs.mostRecentRequest,
22029 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22030 assertTrue(GrouperClientWs.mostRecentRequest,
22031 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22032 assertTrue(GrouperClientWs.mostRecentRequest,
22033 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22034 assertTrue(GrouperClientWs.mostRecentRequest,
22035 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22036 assertTrue(GrouperClientWs.mostRecentRequest,
22037 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22038 assertTrue(GrouperClientWs.mostRecentRequest,
22039 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22040
22041
22042
22043
22044 baos = new ByteArrayOutputStream();
22045 System.setOut(new PrintStream(baos));
22046
22047 GrouperClient.main(GrouperClientUtils.splitTrim(
22048 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId() +
22049 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
22050 "--attributeDefValueType=string --value=123",
22051 " "));
22052
22053
22054 System.out.flush();
22055 output = new String(baos.toByteArray());
22056
22057 System.setOut(systemOut);
22058
22059 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22060
22061 assertEquals(0, GrouperUtil.length(outputLines));
22062
22063
22064
22065
22066 assertTrue(GrouperClientWs.mostRecentRequest,
22067 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22068 assertTrue(GrouperClientWs.mostRecentRequest,
22069 !GrouperClientWs.mostRecentRequest.contains("actions"));
22070 assertTrue(GrouperClientWs.mostRecentRequest,
22071 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22072 assertTrue(GrouperClientWs.mostRecentRequest,
22073 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22074 assertTrue(GrouperClientWs.mostRecentRequest,
22075 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22076 assertTrue(GrouperClientWs.mostRecentRequest,
22077 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22078 assertTrue(GrouperClientWs.mostRecentRequest,
22079 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22080 assertTrue(GrouperClientWs.mostRecentRequest,
22081 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22082 assertTrue(GrouperClientWs.mostRecentRequest,
22083 !GrouperClientWs.mostRecentRequest.contains("params"));
22084 assertTrue(GrouperClientWs.mostRecentRequest,
22085 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22086 assertTrue(GrouperClientWs.mostRecentRequest,
22087 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22088 assertTrue(GrouperClientWs.mostRecentRequest,
22089 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
22090 assertTrue(GrouperClientWs.mostRecentRequest,
22091 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22092 assertTrue(GrouperClientWs.mostRecentRequest,
22093 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22094 assertTrue(GrouperClientWs.mostRecentRequest,
22095 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22096 assertTrue(GrouperClientWs.mostRecentRequest,
22097 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22098 assertTrue(GrouperClientWs.mostRecentRequest,
22099 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22100 assertTrue(GrouperClientWs.mostRecentRequest,
22101 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22102 assertTrue(GrouperClientWs.mostRecentRequest,
22103 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22104 assertTrue(GrouperClientWs.mostRecentRequest,
22105 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22106 assertTrue(GrouperClientWs.mostRecentRequest,
22107 GrouperClientWs.mostRecentRequest.contains("theValue"));
22108 assertTrue(GrouperClientWs.mostRecentRequest,
22109 GrouperClientWs.mostRecentRequest.contains(">123<"));
22110 assertTrue(GrouperClientWs.mostRecentRequest,
22111 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22112 assertTrue(GrouperClientWs.mostRecentRequest,
22113 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22114 assertTrue(GrouperClientWs.mostRecentRequest,
22115 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22116 assertTrue(GrouperClientWs.mostRecentRequest,
22117 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22118 assertTrue(GrouperClientWs.mostRecentRequest,
22119 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22120 assertTrue(GrouperClientWs.mostRecentRequest,
22121 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22122 assertTrue(GrouperClientWs.mostRecentRequest,
22123 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22124 assertTrue(GrouperClientWs.mostRecentRequest,
22125 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22126
22127
22128
22129
22130
22131 baos = new ByteArrayOutputStream();
22132 System.setOut(new PrintStream(baos));
22133
22134 try {
22135 GrouperClient.main(GrouperClientUtils.splitTrim(
22136 " --operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=123" + attributeDef.getId() +
22137 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
22138 "--attributeDefValueType=string --value=123",
22139 " "));
22140 fail("Shouldnt get here");
22141 } catch (GcWebServiceError gwse) {
22142
22143 }
22144
22145
22146
22147
22148 baos = new ByteArrayOutputStream();
22149 System.setOut(new PrintStream(baos));
22150
22151 GrouperClient.main(GrouperClientUtils.splitTrim(
22152 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId() +
22153 " --attributeDefValueType=string --value=abc --attributeDefType=attr",
22154 " "));
22155
22156
22157 System.out.flush();
22158 output = new String(baos.toByteArray());
22159
22160 System.setOut(systemOut);
22161
22162 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22163
22164
22165
22166 pattern = Pattern
22167 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22168
22169 assertEquals(1, GrouperUtil.length(outputLines));
22170 outputLine = outputLines[0];
22171
22172 matcher = pattern.matcher(outputLines[0]);
22173
22174 assertTrue(outputLine, matcher.matches());
22175 assertEquals(outputLine, "0", matcher.group(1));
22176 assertEquals(outputLine, "group", matcher.group(2));
22177 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
22178 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
22179 assertEquals(outputLine, "assign", matcher.group(5));
22180 assertEquals(outputLine, "abc", matcher.group(6));
22181 assertEquals(outputLine, "T", matcher.group(7));
22182 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
22183
22184 assertTrue(GrouperClientWs.mostRecentRequest,
22185 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22186 assertTrue(GrouperClientWs.mostRecentRequest,
22187 !GrouperClientWs.mostRecentRequest.contains("actions"));
22188 assertTrue(GrouperClientWs.mostRecentRequest,
22189 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22190 assertTrue(GrouperClientWs.mostRecentRequest,
22191 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22192 assertTrue(GrouperClientWs.mostRecentRequest,
22193 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22194 assertTrue(GrouperClientWs.mostRecentRequest,
22195 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22196 assertTrue(GrouperClientWs.mostRecentRequest,
22197 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22198 assertTrue(GrouperClientWs.mostRecentRequest,
22199 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22200 assertTrue(GrouperClientWs.mostRecentRequest,
22201 !GrouperClientWs.mostRecentRequest.contains("params"));
22202 assertTrue(GrouperClientWs.mostRecentRequest,
22203 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22204 assertTrue(GrouperClientWs.mostRecentRequest,
22205 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22206 assertTrue(GrouperClientWs.mostRecentRequest,
22207 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22208 assertTrue(GrouperClientWs.mostRecentRequest,
22209 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22210 assertTrue(GrouperClientWs.mostRecentRequest,
22211 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22212 assertTrue(GrouperClientWs.mostRecentRequest,
22213 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22214 assertTrue(GrouperClientWs.mostRecentRequest,
22215 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22216 assertTrue(GrouperClientWs.mostRecentRequest,
22217 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22218 assertTrue(GrouperClientWs.mostRecentRequest,
22219 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22220 assertTrue(GrouperClientWs.mostRecentRequest,
22221 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22222 assertTrue(GrouperClientWs.mostRecentRequest,
22223 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22224 assertTrue(GrouperClientWs.mostRecentRequest,
22225 GrouperClientWs.mostRecentRequest.contains("theValue"));
22226 assertTrue(GrouperClientWs.mostRecentRequest,
22227 GrouperClientWs.mostRecentRequest.contains("abc"));
22228 assertTrue(GrouperClientWs.mostRecentRequest,
22229 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22230 assertTrue(GrouperClientWs.mostRecentRequest,
22231 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22232 assertTrue(GrouperClientWs.mostRecentRequest,
22233 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22234 assertTrue(GrouperClientWs.mostRecentRequest,
22235 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22236 assertTrue(GrouperClientWs.mostRecentRequest,
22237 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22238 assertTrue(GrouperClientWs.mostRecentRequest,
22239 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22240 assertTrue(GrouperClientWs.mostRecentRequest,
22241 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22242 assertTrue(GrouperClientWs.mostRecentRequest,
22243 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22244
22245
22246
22247
22248 baos = new ByteArrayOutputStream();
22249 System.setOut(new PrintStream(baos));
22250
22251 GrouperClient.main(GrouperClientUtils.splitTrim(
22252 "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId() +
22253 " --attributeDefValueType=string --value=abc --attributeDefType=limit",
22254 " "));
22255
22256 System.out.flush();
22257 output = new String(baos.toByteArray());
22258
22259 System.setOut(systemOut);
22260
22261 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22262
22263
22264
22265 pattern = Pattern
22266 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22267
22268 assertEquals(0, GrouperUtil.length(outputLines));
22269
22270 assertTrue(GrouperClientWs.mostRecentRequest,
22271 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22272 assertTrue(GrouperClientWs.mostRecentRequest,
22273 !GrouperClientWs.mostRecentRequest.contains("actions"));
22274 assertTrue(GrouperClientWs.mostRecentRequest,
22275 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22276 assertTrue(GrouperClientWs.mostRecentRequest,
22277 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22278 assertTrue(GrouperClientWs.mostRecentRequest,
22279 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22280 assertTrue(GrouperClientWs.mostRecentRequest,
22281 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22282 assertTrue(GrouperClientWs.mostRecentRequest,
22283 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22284 assertTrue(GrouperClientWs.mostRecentRequest,
22285 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22286 assertTrue(GrouperClientWs.mostRecentRequest,
22287 !GrouperClientWs.mostRecentRequest.contains("params"));
22288 assertTrue(GrouperClientWs.mostRecentRequest,
22289 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22290 assertTrue(GrouperClientWs.mostRecentRequest,
22291 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22292 assertTrue(GrouperClientWs.mostRecentRequest,
22293 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22294 assertTrue(GrouperClientWs.mostRecentRequest,
22295 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22296 assertTrue(GrouperClientWs.mostRecentRequest,
22297 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22298 assertTrue(GrouperClientWs.mostRecentRequest,
22299 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22300 assertTrue(GrouperClientWs.mostRecentRequest,
22301 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22302 assertTrue(GrouperClientWs.mostRecentRequest,
22303 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22304 assertTrue(GrouperClientWs.mostRecentRequest,
22305 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22306 assertTrue(GrouperClientWs.mostRecentRequest,
22307 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22308 assertTrue(GrouperClientWs.mostRecentRequest,
22309 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22310 assertTrue(GrouperClientWs.mostRecentRequest,
22311 GrouperClientWs.mostRecentRequest.contains("theValue"));
22312 assertTrue(GrouperClientWs.mostRecentRequest,
22313 GrouperClientWs.mostRecentRequest.contains("abc"));
22314 assertTrue(GrouperClientWs.mostRecentRequest,
22315 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22316 assertTrue(GrouperClientWs.mostRecentRequest,
22317 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22318 assertTrue(GrouperClientWs.mostRecentRequest,
22319 GrouperClientWs.mostRecentRequest.contains("limit"));
22320 assertTrue(GrouperClientWs.mostRecentRequest,
22321 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22322 assertTrue(GrouperClientWs.mostRecentRequest,
22323 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22324 assertTrue(GrouperClientWs.mostRecentRequest,
22325 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22326 assertTrue(GrouperClientWs.mostRecentRequest,
22327 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22328 assertTrue(GrouperClientWs.mostRecentRequest,
22329 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22330 assertTrue(GrouperClientWs.mostRecentRequest,
22331 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22332
22333
22334
22335
22336 baos = new ByteArrayOutputStream();
22337 System.setOut(new PrintStream(baos));
22338
22339 GrouperClient.main(GrouperClientUtils.splitTrim(
22340 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId(),
22341 " "));
22342
22343 System.out.flush();
22344 output = new String(baos.toByteArray());
22345
22346 System.setOut(systemOut);
22347
22348 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22349
22350
22351
22352 pattern = Pattern
22353 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22354
22355 assertEquals(1, GrouperUtil.length(outputLines));
22356 outputLine = outputLines[0];
22357
22358 matcher = pattern.matcher(outputLines[0]);
22359
22360 assertTrue(outputLine, matcher.matches());
22361 assertEquals(outputLine, "0", matcher.group(1));
22362 assertEquals(outputLine, "group_asgn", matcher.group(2));
22363 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22364 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22365 assertEquals(outputLine, "assign", matcher.group(5));
22366 assertEquals(outputLine, "123", matcher.group(6));
22367 assertEquals(outputLine, "T", matcher.group(7));
22368 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22369
22370 assertTrue(GrouperClientWs.mostRecentRequest,
22371 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22372 assertTrue(GrouperClientWs.mostRecentRequest,
22373 !GrouperClientWs.mostRecentRequest.contains("actions"));
22374 assertTrue(GrouperClientWs.mostRecentRequest,
22375 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22376 assertTrue(GrouperClientWs.mostRecentRequest,
22377 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22378 assertTrue(GrouperClientWs.mostRecentRequest,
22379 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22380 assertTrue(GrouperClientWs.mostRecentRequest,
22381 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22382 assertTrue(GrouperClientWs.mostRecentRequest,
22383 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22384 assertTrue(GrouperClientWs.mostRecentRequest,
22385 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22386 assertTrue(GrouperClientWs.mostRecentRequest,
22387 !GrouperClientWs.mostRecentRequest.contains("params"));
22388 assertTrue(GrouperClientWs.mostRecentRequest,
22389 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22390 assertTrue(GrouperClientWs.mostRecentRequest,
22391 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22392 assertTrue(GrouperClientWs.mostRecentRequest,
22393 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22394 assertTrue(GrouperClientWs.mostRecentRequest,
22395 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22396 assertTrue(GrouperClientWs.mostRecentRequest,
22397 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22398 assertTrue(GrouperClientWs.mostRecentRequest,
22399 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22400 assertTrue(GrouperClientWs.mostRecentRequest,
22401 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22402 assertTrue(GrouperClientWs.mostRecentRequest,
22403 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22404 assertTrue(GrouperClientWs.mostRecentRequest,
22405 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22406 assertTrue(GrouperClientWs.mostRecentRequest,
22407 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22408 assertFalse(GrouperClientWs.mostRecentRequest,
22409 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22410 assertFalse(GrouperClientWs.mostRecentRequest,
22411 GrouperClientWs.mostRecentRequest.contains("theValue"));
22412 assertFalse(GrouperClientWs.mostRecentRequest,
22413 GrouperClientWs.mostRecentRequest.contains(">abc<"));
22414 assertTrue(GrouperClientWs.mostRecentRequest,
22415 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22416 assertFalse(GrouperClientWs.mostRecentRequest,
22417 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22418 assertTrue(GrouperClientWs.mostRecentRequest,
22419 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22420 assertTrue(GrouperClientWs.mostRecentRequest,
22421 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22422 assertTrue(GrouperClientWs.mostRecentRequest,
22423 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22424 assertTrue(GrouperClientWs.mostRecentRequest,
22425 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22426 assertTrue(GrouperClientWs.mostRecentRequest,
22427 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22428 assertTrue(GrouperClientWs.mostRecentRequest,
22429 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22430
22431
22432
22433
22434 baos = new ByteArrayOutputStream();
22435 System.setOut(new PrintStream(baos));
22436
22437 try {
22438 GrouperClient.main(GrouperClientUtils.splitTrim(
22439 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=1" + attributeDef2.getId(),
22440 " "));
22441
22442 System.out.flush();
22443 output = new String(baos.toByteArray());
22444
22445 System.setOut(systemOut);
22446
22447 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22448
22449
22450
22451 pattern = Pattern
22452 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22453
22454 assertEquals(0, GrouperUtil.length(outputLines));
22455 fail("Why did it not fail?");
22456 } catch (Exception e) {
22457
22458 }
22459 assertTrue(GrouperClientWs.mostRecentRequest,
22460 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22461 assertTrue(GrouperClientWs.mostRecentRequest,
22462 !GrouperClientWs.mostRecentRequest.contains("actions"));
22463 assertTrue(GrouperClientWs.mostRecentRequest,
22464 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22465 assertTrue(GrouperClientWs.mostRecentRequest,
22466 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22467 assertTrue(GrouperClientWs.mostRecentRequest,
22468 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22469 assertTrue(GrouperClientWs.mostRecentRequest,
22470 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22471 assertTrue(GrouperClientWs.mostRecentRequest,
22472 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22473 assertTrue(GrouperClientWs.mostRecentRequest,
22474 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22475 assertTrue(GrouperClientWs.mostRecentRequest,
22476 !GrouperClientWs.mostRecentRequest.contains("params"));
22477 assertTrue(GrouperClientWs.mostRecentRequest,
22478 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22479 assertTrue(GrouperClientWs.mostRecentRequest,
22480 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22481 assertTrue(GrouperClientWs.mostRecentRequest,
22482 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22483 assertTrue(GrouperClientWs.mostRecentRequest,
22484 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22485 assertTrue(GrouperClientWs.mostRecentRequest,
22486 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22487 assertTrue(GrouperClientWs.mostRecentRequest,
22488 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22489 assertTrue(GrouperClientWs.mostRecentRequest,
22490 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22491 assertTrue(GrouperClientWs.mostRecentRequest,
22492 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22493 assertTrue(GrouperClientWs.mostRecentRequest,
22494 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22495 assertTrue(GrouperClientWs.mostRecentRequest,
22496 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22497 assertFalse(GrouperClientWs.mostRecentRequest,
22498 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22499 assertFalse(GrouperClientWs.mostRecentRequest,
22500 GrouperClientWs.mostRecentRequest.contains("theValue"));
22501 assertFalse(GrouperClientWs.mostRecentRequest,
22502 GrouperClientWs.mostRecentRequest.contains("abc"));
22503 assertTrue(GrouperClientWs.mostRecentRequest,
22504 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22505 assertFalse(GrouperClientWs.mostRecentRequest,
22506 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22507 assertTrue(GrouperClientWs.mostRecentRequest,
22508 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22509 assertTrue(GrouperClientWs.mostRecentRequest,
22510 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22511 assertTrue(GrouperClientWs.mostRecentRequest,
22512 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22513 assertTrue(GrouperClientWs.mostRecentRequest,
22514 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22515 assertTrue(GrouperClientWs.mostRecentRequest,
22516 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22517 assertTrue(GrouperClientWs.mostRecentRequest,
22518 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22519
22520
22521
22522
22523
22524 baos = new ByteArrayOutputStream();
22525 System.setOut(new PrintStream(baos));
22526
22527 GrouperClient.main(GrouperClientUtils.splitTrim(
22528 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId()
22529 + " --attributeDefValueType=integer --value=123 ",
22530 " "));
22531
22532 System.out.flush();
22533 output = new String(baos.toByteArray());
22534
22535 System.setOut(systemOut);
22536
22537 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22538
22539
22540
22541 pattern = Pattern
22542 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22543
22544 assertEquals(1, GrouperUtil.length(outputLines));
22545 outputLine = outputLines[0];
22546
22547 matcher = pattern.matcher(outputLines[0]);
22548
22549 assertTrue(outputLine, matcher.matches());
22550 assertEquals(outputLine, "0", matcher.group(1));
22551 assertEquals(outputLine, "group_asgn", matcher.group(2));
22552 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22553 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22554 assertEquals(outputLine, "assign", matcher.group(5));
22555 assertEquals(outputLine, "123", matcher.group(6));
22556 assertEquals(outputLine, "T", matcher.group(7));
22557 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22558
22559 assertTrue(GrouperClientWs.mostRecentRequest,
22560 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22561 assertTrue(GrouperClientWs.mostRecentRequest,
22562 !GrouperClientWs.mostRecentRequest.contains("actions"));
22563 assertTrue(GrouperClientWs.mostRecentRequest,
22564 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22565 assertTrue(GrouperClientWs.mostRecentRequest,
22566 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22567 assertTrue(GrouperClientWs.mostRecentRequest,
22568 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22569 assertTrue(GrouperClientWs.mostRecentRequest,
22570 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22571 assertTrue(GrouperClientWs.mostRecentRequest,
22572 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22573 assertTrue(GrouperClientWs.mostRecentRequest,
22574 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22575 assertTrue(GrouperClientWs.mostRecentRequest,
22576 !GrouperClientWs.mostRecentRequest.contains("params"));
22577 assertTrue(GrouperClientWs.mostRecentRequest,
22578 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22579 assertTrue(GrouperClientWs.mostRecentRequest,
22580 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22581 assertTrue(GrouperClientWs.mostRecentRequest,
22582 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22583 assertTrue(GrouperClientWs.mostRecentRequest,
22584 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22585 assertTrue(GrouperClientWs.mostRecentRequest,
22586 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22587 assertTrue(GrouperClientWs.mostRecentRequest,
22588 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22589 assertTrue(GrouperClientWs.mostRecentRequest,
22590 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22591 assertTrue(GrouperClientWs.mostRecentRequest,
22592 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22593 assertTrue(GrouperClientWs.mostRecentRequest,
22594 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22595 assertTrue(GrouperClientWs.mostRecentRequest,
22596 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22597 assertTrue(GrouperClientWs.mostRecentRequest,
22598 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22599 assertTrue(GrouperClientWs.mostRecentRequest,
22600 GrouperClientWs.mostRecentRequest.contains("theValue"));
22601 assertTrue(GrouperClientWs.mostRecentRequest,
22602 GrouperClientWs.mostRecentRequest.contains(">123<"));
22603 assertTrue(GrouperClientWs.mostRecentRequest,
22604 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22605 assertFalse(GrouperClientWs.mostRecentRequest,
22606 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22607 assertTrue(GrouperClientWs.mostRecentRequest,
22608 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22609 assertTrue(GrouperClientWs.mostRecentRequest,
22610 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22611 assertTrue(GrouperClientWs.mostRecentRequest,
22612 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22613 assertTrue(GrouperClientWs.mostRecentRequest,
22614 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22615 assertTrue(GrouperClientWs.mostRecentRequest,
22616 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22617 assertTrue(GrouperClientWs.mostRecentRequest,
22618 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22619
22620
22621
22622
22623
22624 baos = new ByteArrayOutputStream();
22625 System.setOut(new PrintStream(baos));
22626
22627 GrouperClient.main(GrouperClientUtils.splitTrim(
22628 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId()
22629 + " --attributeDefValueType=integer --value=1234 ",
22630 " "));
22631
22632 System.out.flush();
22633 output = new String(baos.toByteArray());
22634
22635 System.setOut(systemOut);
22636
22637 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22638
22639
22640
22641 pattern = Pattern
22642 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22643
22644 assertEquals(0, GrouperUtil.length(outputLines));
22645
22646 assertTrue(GrouperClientWs.mostRecentRequest,
22647 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22648 assertTrue(GrouperClientWs.mostRecentRequest,
22649 !GrouperClientWs.mostRecentRequest.contains("actions"));
22650 assertTrue(GrouperClientWs.mostRecentRequest,
22651 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22652 assertTrue(GrouperClientWs.mostRecentRequest,
22653 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22654 assertTrue(GrouperClientWs.mostRecentRequest,
22655 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22656 assertTrue(GrouperClientWs.mostRecentRequest,
22657 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22658 assertTrue(GrouperClientWs.mostRecentRequest,
22659 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22660 assertTrue(GrouperClientWs.mostRecentRequest,
22661 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22662 assertTrue(GrouperClientWs.mostRecentRequest,
22663 !GrouperClientWs.mostRecentRequest.contains("params"));
22664 assertTrue(GrouperClientWs.mostRecentRequest,
22665 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22666 assertTrue(GrouperClientWs.mostRecentRequest,
22667 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22668 assertTrue(GrouperClientWs.mostRecentRequest,
22669 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22670 assertTrue(GrouperClientWs.mostRecentRequest,
22671 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22672 assertTrue(GrouperClientWs.mostRecentRequest,
22673 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22674 assertTrue(GrouperClientWs.mostRecentRequest,
22675 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22676 assertTrue(GrouperClientWs.mostRecentRequest,
22677 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22678 assertTrue(GrouperClientWs.mostRecentRequest,
22679 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22680 assertTrue(GrouperClientWs.mostRecentRequest,
22681 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22682 assertTrue(GrouperClientWs.mostRecentRequest,
22683 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22684 assertTrue(GrouperClientWs.mostRecentRequest,
22685 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22686 assertTrue(GrouperClientWs.mostRecentRequest,
22687 GrouperClientWs.mostRecentRequest.contains("theValue"));
22688 assertTrue(GrouperClientWs.mostRecentRequest,
22689 GrouperClientWs.mostRecentRequest.contains("1234"));
22690 assertTrue(GrouperClientWs.mostRecentRequest,
22691 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22692 assertFalse(GrouperClientWs.mostRecentRequest,
22693 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22694 assertTrue(GrouperClientWs.mostRecentRequest,
22695 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22696 assertTrue(GrouperClientWs.mostRecentRequest,
22697 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22698 assertTrue(GrouperClientWs.mostRecentRequest,
22699 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22700 assertTrue(GrouperClientWs.mostRecentRequest,
22701 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22702 assertTrue(GrouperClientWs.mostRecentRequest,
22703 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22704 assertTrue(GrouperClientWs.mostRecentRequest,
22705 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22706
22707
22708
22709
22710
22711 baos = new ByteArrayOutputStream();
22712 System.setOut(new PrintStream(baos));
22713
22714 GrouperClient.main(GrouperClientUtils.splitTrim(
22715 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId()
22716 + " --includeAssignmentsFromAssignments=T ",
22717 " "));
22718
22719 System.out.flush();
22720 output = new String(baos.toByteArray());
22721
22722 System.setOut(systemOut);
22723
22724 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22725
22726
22727
22728 pattern = Pattern
22729 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22730
22731 assertEquals(2, GrouperUtil.length(outputLines));
22732 outputLine = outputLines[0];
22733
22734 matcher = pattern.matcher(outputLine);
22735
22736 assertTrue(outputLine, matcher.matches());
22737 assertEquals(outputLine, "0", matcher.group(1));
22738 assertEquals(outputLine, "group", matcher.group(2));
22739 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
22740 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
22741 assertEquals(outputLine, "assign", matcher.group(5));
22742 assertEquals(outputLine, "abc", matcher.group(6));
22743 assertEquals(outputLine, "T", matcher.group(7));
22744 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
22745
22746 outputLine = outputLines[1];
22747
22748 matcher = pattern.matcher(outputLine);
22749
22750 assertTrue(outputLine, matcher.matches());
22751 assertEquals(outputLine, "1", matcher.group(1));
22752 assertEquals(outputLine, "group_asgn", matcher.group(2));
22753 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22754 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22755 assertEquals(outputLine, "assign", matcher.group(5));
22756 assertEquals(outputLine, "123", matcher.group(6));
22757 assertEquals(outputLine, "T", matcher.group(7));
22758 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22759
22760 assertTrue(GrouperClientWs.mostRecentRequest,
22761 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22762 assertTrue(GrouperClientWs.mostRecentRequest,
22763 !GrouperClientWs.mostRecentRequest.contains("actions"));
22764 assertTrue(GrouperClientWs.mostRecentRequest,
22765 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22766 assertTrue(GrouperClientWs.mostRecentRequest,
22767 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22768 assertTrue(GrouperClientWs.mostRecentRequest,
22769 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22770 assertTrue(GrouperClientWs.mostRecentRequest,
22771 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22772 assertTrue(GrouperClientWs.mostRecentRequest,
22773 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22774 assertTrue(GrouperClientWs.mostRecentRequest,
22775 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22776 assertTrue(GrouperClientWs.mostRecentRequest,
22777 !GrouperClientWs.mostRecentRequest.contains("params"));
22778 assertTrue(GrouperClientWs.mostRecentRequest,
22779 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22780 assertTrue(GrouperClientWs.mostRecentRequest,
22781 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22782 assertTrue(GrouperClientWs.mostRecentRequest,
22783 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22784 assertTrue(GrouperClientWs.mostRecentRequest,
22785 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22786 assertTrue(GrouperClientWs.mostRecentRequest,
22787 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22788 assertTrue(GrouperClientWs.mostRecentRequest,
22789 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22790 assertTrue(GrouperClientWs.mostRecentRequest,
22791 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22792 assertTrue(GrouperClientWs.mostRecentRequest,
22793 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22794 assertTrue(GrouperClientWs.mostRecentRequest,
22795 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22796 assertTrue(GrouperClientWs.mostRecentRequest,
22797 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22798 assertFalse(GrouperClientWs.mostRecentRequest,
22799 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22800 assertFalse(GrouperClientWs.mostRecentRequest,
22801 GrouperClientWs.mostRecentRequest.contains("theValue"));
22802 assertFalse(GrouperClientWs.mostRecentRequest,
22803 GrouperClientWs.mostRecentRequest.contains(">123<"));
22804 assertTrue(GrouperClientWs.mostRecentRequest,
22805 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22806 assertFalse(GrouperClientWs.mostRecentRequest,
22807 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22808 assertTrue(GrouperClientWs.mostRecentRequest,
22809 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22810 assertTrue(GrouperClientWs.mostRecentRequest,
22811 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22812 assertTrue(GrouperClientWs.mostRecentRequest,
22813 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22814 assertTrue(GrouperClientWs.mostRecentRequest,
22815 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22816 assertTrue(GrouperClientWs.mostRecentRequest,
22817 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22818 assertTrue(GrouperClientWs.mostRecentRequest,
22819 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22820
22821
22822
22823
22824
22825 baos = new ByteArrayOutputStream();
22826 System.setOut(new PrintStream(baos));
22827
22828 try {
22829 GrouperClient.main(GrouperClientUtils.splitTrim(
22830 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
22831 ,
22832 " "));
22833
22834 System.out.flush();
22835 output = new String(baos.toByteArray());
22836
22837 System.setOut(systemOut);
22838
22839 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22840
22841
22842
22843 pattern = Pattern
22844 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22845
22846 assertEquals(0, GrouperUtil.length(outputLines));
22847 fail("Shouldnt get here");
22848 } catch (Exception e) {
22849
22850 } finally {
22851 System.setOut(systemOut);
22852
22853 }
22854
22855 assertTrue(GrouperClientWs.mostRecentRequest,
22856 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22857 assertTrue(GrouperClientWs.mostRecentRequest,
22858 !GrouperClientWs.mostRecentRequest.contains("actions"));
22859 assertTrue(GrouperClientWs.mostRecentRequest,
22860 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22861 assertTrue(GrouperClientWs.mostRecentRequest,
22862 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22863 assertTrue(GrouperClientWs.mostRecentRequest,
22864 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22865 assertTrue(GrouperClientWs.mostRecentRequest,
22866 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22867 assertTrue(GrouperClientWs.mostRecentRequest,
22868 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22869 assertTrue(GrouperClientWs.mostRecentRequest,
22870 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22871 assertTrue(GrouperClientWs.mostRecentRequest,
22872 !GrouperClientWs.mostRecentRequest.contains("params"));
22873 assertTrue(GrouperClientWs.mostRecentRequest,
22874 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22875 assertTrue(GrouperClientWs.mostRecentRequest,
22876 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22877 assertFalse(GrouperClientWs.mostRecentRequest,
22878 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
22879 assertTrue(GrouperClientWs.mostRecentRequest,
22880 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22881 assertTrue(GrouperClientWs.mostRecentRequest,
22882 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22883 assertTrue(GrouperClientWs.mostRecentRequest,
22884 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22885 assertTrue(GrouperClientWs.mostRecentRequest,
22886 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22887 assertTrue(GrouperClientWs.mostRecentRequest,
22888 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22889 assertTrue(GrouperClientWs.mostRecentRequest,
22890 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22891 assertTrue(GrouperClientWs.mostRecentRequest,
22892 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22893 assertTrue(GrouperClientWs.mostRecentRequest,
22894 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22895 assertFalse(GrouperClientWs.mostRecentRequest,
22896 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22897 assertFalse(GrouperClientWs.mostRecentRequest,
22898 GrouperClientWs.mostRecentRequest.contains("theValue"));
22899 assertFalse(GrouperClientWs.mostRecentRequest,
22900 GrouperClientWs.mostRecentRequest.contains(">123<"));
22901 assertFalse(GrouperClientWs.mostRecentRequest,
22902 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22903 assertFalse(GrouperClientWs.mostRecentRequest,
22904 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22905 assertTrue(GrouperClientWs.mostRecentRequest,
22906 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22907 assertTrue(GrouperClientWs.mostRecentRequest,
22908 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22909 assertTrue(GrouperClientWs.mostRecentRequest,
22910 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22911 assertTrue(GrouperClientWs.mostRecentRequest,
22912 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22913 assertTrue(GrouperClientWs.mostRecentRequest,
22914 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22915 assertTrue(GrouperClientWs.mostRecentRequest,
22916 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22917
22918
22919
22920
22921 baos = new ByteArrayOutputStream();
22922 System.setOut(new PrintStream(baos));
22923
22924 GrouperClient.main(GrouperClientUtils.splitTrim(
22925 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
22926 ,
22927 " "));
22928
22929 System.out.flush();
22930 output = new String(baos.toByteArray());
22931
22932 System.setOut(systemOut);
22933
22934 outputLines = GrouperClientUtils.splitTrim(output, "\n");
22935
22936
22937
22938 pattern = Pattern
22939 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22940
22941 assertEquals(1, GrouperUtil.length(outputLines));
22942
22943 outputLine = outputLines[0];
22944
22945 matcher = pattern.matcher(outputLine);
22946
22947 assertTrue(outputLine, matcher.matches());
22948 assertEquals(outputLine, "0", matcher.group(1));
22949 assertEquals(outputLine, "group_asgn", matcher.group(2));
22950 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22951 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22952 assertEquals(outputLine, "assign", matcher.group(5));
22953 assertEquals(outputLine, "123", matcher.group(6));
22954 assertEquals(outputLine, "T", matcher.group(7));
22955 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22956
22957 assertTrue(GrouperClientWs.mostRecentRequest,
22958 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22959 assertTrue(GrouperClientWs.mostRecentRequest,
22960 !GrouperClientWs.mostRecentRequest.contains("actions"));
22961 assertTrue(GrouperClientWs.mostRecentRequest,
22962 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22963 assertTrue(GrouperClientWs.mostRecentRequest,
22964 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22965 assertTrue(GrouperClientWs.mostRecentRequest,
22966 !GrouperClientWs.mostRecentRequest.contains("enabled"));
22967 assertTrue(GrouperClientWs.mostRecentRequest,
22968 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22969 assertTrue(GrouperClientWs.mostRecentRequest,
22970 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22971 assertTrue(GrouperClientWs.mostRecentRequest,
22972 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22973 assertTrue(GrouperClientWs.mostRecentRequest,
22974 !GrouperClientWs.mostRecentRequest.contains("params"));
22975 assertTrue(GrouperClientWs.mostRecentRequest,
22976 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22977 assertTrue(GrouperClientWs.mostRecentRequest,
22978 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22979 assertFalse(GrouperClientWs.mostRecentRequest,
22980 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
22981 assertTrue(GrouperClientWs.mostRecentRequest,
22982 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22983 assertTrue(GrouperClientWs.mostRecentRequest,
22984 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22985 assertTrue(GrouperClientWs.mostRecentRequest,
22986 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22987 assertTrue(GrouperClientWs.mostRecentRequest,
22988 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22989 assertTrue(GrouperClientWs.mostRecentRequest,
22990 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22991 assertTrue(GrouperClientWs.mostRecentRequest,
22992 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22993 assertTrue(GrouperClientWs.mostRecentRequest,
22994 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22995 assertTrue(GrouperClientWs.mostRecentRequest,
22996 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22997 assertFalse(GrouperClientWs.mostRecentRequest,
22998 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22999 assertFalse(GrouperClientWs.mostRecentRequest,
23000 GrouperClientWs.mostRecentRequest.contains("theValue"));
23001 assertFalse(GrouperClientWs.mostRecentRequest,
23002 GrouperClientWs.mostRecentRequest.contains(">123<"));
23003 assertFalse(GrouperClientWs.mostRecentRequest,
23004 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23005 assertFalse(GrouperClientWs.mostRecentRequest,
23006 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23007 assertTrue(GrouperClientWs.mostRecentRequest,
23008 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23009 assertTrue(GrouperClientWs.mostRecentRequest,
23010 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23011 assertTrue(GrouperClientWs.mostRecentRequest,
23012 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23013 assertTrue(GrouperClientWs.mostRecentRequest,
23014 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23015 assertTrue(GrouperClientWs.mostRecentRequest,
23016 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23017 assertTrue(GrouperClientWs.mostRecentRequest,
23018 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23019
23020
23021
23022
23023
23024 baos = new ByteArrayOutputStream();
23025 System.setOut(new PrintStream(baos));
23026
23027 GrouperClient.main(GrouperClientUtils.splitTrim(
23028 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
23029 ,
23030 " "));
23031
23032 System.out.flush();
23033 output = new String(baos.toByteArray());
23034
23035 System.setOut(systemOut);
23036
23037 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23038
23039
23040
23041 pattern = Pattern
23042 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23043
23044 assertEquals(1, GrouperUtil.length(outputLines));
23045
23046 outputLine = outputLines[0];
23047
23048 matcher = pattern.matcher(outputLine);
23049
23050 assertTrue(outputLine, matcher.matches());
23051 assertEquals(outputLine, "0", matcher.group(1));
23052 assertEquals(outputLine, "group_asgn", matcher.group(2));
23053 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23054 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23055 assertEquals(outputLine, "assign", matcher.group(5));
23056 assertEquals(outputLine, "123", matcher.group(6));
23057 assertEquals(outputLine, "T", matcher.group(7));
23058 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23059
23060 assertTrue(GrouperClientWs.mostRecentRequest,
23061 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23062 assertTrue(GrouperClientWs.mostRecentRequest,
23063 !GrouperClientWs.mostRecentRequest.contains("actions"));
23064 assertTrue(GrouperClientWs.mostRecentRequest,
23065 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23066 assertTrue(GrouperClientWs.mostRecentRequest,
23067 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23068 assertTrue(GrouperClientWs.mostRecentRequest,
23069 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23070 assertTrue(GrouperClientWs.mostRecentRequest,
23071 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23072 assertTrue(GrouperClientWs.mostRecentRequest,
23073 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23074 assertTrue(GrouperClientWs.mostRecentRequest,
23075 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23076 assertTrue(GrouperClientWs.mostRecentRequest,
23077 !GrouperClientWs.mostRecentRequest.contains("params"));
23078 assertTrue(GrouperClientWs.mostRecentRequest,
23079 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23080 assertTrue(GrouperClientWs.mostRecentRequest,
23081 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23082 assertFalse(GrouperClientWs.mostRecentRequest,
23083 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23084 assertFalse(GrouperClientWs.mostRecentRequest,
23085 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23086 assertTrue(GrouperClientWs.mostRecentRequest,
23087 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23088 assertTrue(GrouperClientWs.mostRecentRequest,
23089 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23090 assertTrue(GrouperClientWs.mostRecentRequest,
23091 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23092 assertTrue(GrouperClientWs.mostRecentRequest,
23093 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23094 assertTrue(GrouperClientWs.mostRecentRequest,
23095 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23096 assertTrue(GrouperClientWs.mostRecentRequest,
23097 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23098 assertTrue(GrouperClientWs.mostRecentRequest,
23099 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23100 assertFalse(GrouperClientWs.mostRecentRequest,
23101 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23102 assertFalse(GrouperClientWs.mostRecentRequest,
23103 GrouperClientWs.mostRecentRequest.contains("theValue"));
23104 assertFalse(GrouperClientWs.mostRecentRequest,
23105 GrouperClientWs.mostRecentRequest.contains(">123<"));
23106 assertFalse(GrouperClientWs.mostRecentRequest,
23107 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23108 assertFalse(GrouperClientWs.mostRecentRequest,
23109 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23110 assertTrue(GrouperClientWs.mostRecentRequest,
23111 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23112 assertTrue(GrouperClientWs.mostRecentRequest,
23113 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23114 assertTrue(GrouperClientWs.mostRecentRequest,
23115 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23116 assertTrue(GrouperClientWs.mostRecentRequest,
23117 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23118 assertTrue(GrouperClientWs.mostRecentRequest,
23119 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23120 assertTrue(GrouperClientWs.mostRecentRequest,
23121 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23122
23123
23124
23125
23126
23127
23128 baos = new ByteArrayOutputStream();
23129 System.setOut(new PrintStream(baos));
23130
23131 try {
23132 GrouperClient.main(GrouperClientUtils.splitTrim(
23133 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
23134 ,
23135 " "));
23136
23137 System.out.flush();
23138 output = new String(baos.toByteArray());
23139
23140 System.setOut(systemOut);
23141
23142 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23143
23144
23145
23146 pattern = Pattern
23147 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23148
23149 assertEquals(0, GrouperUtil.length(outputLines));
23150
23151 fail("shouldnt get here");
23152 } catch (Exception e) {
23153
23154 } finally {
23155 System.setOut(systemOut);
23156 }
23157
23158 assertTrue(GrouperClientWs.mostRecentRequest,
23159 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23160 assertTrue(GrouperClientWs.mostRecentRequest,
23161 !GrouperClientWs.mostRecentRequest.contains("actions"));
23162 assertTrue(GrouperClientWs.mostRecentRequest,
23163 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23164 assertTrue(GrouperClientWs.mostRecentRequest,
23165 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23166 assertTrue(GrouperClientWs.mostRecentRequest,
23167 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23168 assertTrue(GrouperClientWs.mostRecentRequest,
23169 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23170 assertTrue(GrouperClientWs.mostRecentRequest,
23171 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23172 assertTrue(GrouperClientWs.mostRecentRequest,
23173 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23174 assertTrue(GrouperClientWs.mostRecentRequest,
23175 !GrouperClientWs.mostRecentRequest.contains("params"));
23176 assertTrue(GrouperClientWs.mostRecentRequest,
23177 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23178 assertTrue(GrouperClientWs.mostRecentRequest,
23179 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23180 assertFalse(GrouperClientWs.mostRecentRequest,
23181 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23182 assertFalse(GrouperClientWs.mostRecentRequest,
23183 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23184 assertTrue(GrouperClientWs.mostRecentRequest,
23185 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23186 assertTrue(GrouperClientWs.mostRecentRequest,
23187 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23188 assertTrue(GrouperClientWs.mostRecentRequest,
23189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23190 assertTrue(GrouperClientWs.mostRecentRequest,
23191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23192 assertTrue(GrouperClientWs.mostRecentRequest,
23193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23194 assertTrue(GrouperClientWs.mostRecentRequest,
23195 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23196 assertTrue(GrouperClientWs.mostRecentRequest,
23197 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23198 assertFalse(GrouperClientWs.mostRecentRequest,
23199 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23200 assertFalse(GrouperClientWs.mostRecentRequest,
23201 GrouperClientWs.mostRecentRequest.contains("theValue"));
23202 assertFalse(GrouperClientWs.mostRecentRequest,
23203 GrouperClientWs.mostRecentRequest.contains(">123<"));
23204 assertFalse(GrouperClientWs.mostRecentRequest,
23205 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23206 assertFalse(GrouperClientWs.mostRecentRequest,
23207 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23208 assertTrue(GrouperClientWs.mostRecentRequest,
23209 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23210 assertTrue(GrouperClientWs.mostRecentRequest,
23211 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23212 assertTrue(GrouperClientWs.mostRecentRequest,
23213 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23214 assertTrue(GrouperClientWs.mostRecentRequest,
23215 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23216 assertTrue(GrouperClientWs.mostRecentRequest,
23217 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23218 assertTrue(GrouperClientWs.mostRecentRequest,
23219 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23220
23221
23222
23223
23224
23225 baos = new ByteArrayOutputStream();
23226 System.setOut(new PrintStream(baos));
23227
23228 GrouperClient.main(GrouperClientUtils.splitTrim(
23229 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
23230 ,
23231 " "));
23232
23233 System.out.flush();
23234 output = new String(baos.toByteArray());
23235
23236 System.setOut(systemOut);
23237
23238 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23239
23240
23241
23242 pattern = Pattern
23243 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23244
23245 assertEquals(1, GrouperUtil.length(outputLines));
23246
23247 outputLine = outputLines[0];
23248
23249 matcher = pattern.matcher(outputLine);
23250
23251 assertTrue(outputLine, matcher.matches());
23252 assertEquals(outputLine, "0", matcher.group(1));
23253 assertEquals(outputLine, "group_asgn", matcher.group(2));
23254 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23255 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23256 assertEquals(outputLine, "assign", matcher.group(5));
23257 assertEquals(outputLine, "123", matcher.group(6));
23258 assertEquals(outputLine, "T", matcher.group(7));
23259 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23260
23261 assertTrue(GrouperClientWs.mostRecentRequest,
23262 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23263 assertTrue(GrouperClientWs.mostRecentRequest,
23264 !GrouperClientWs.mostRecentRequest.contains("actions"));
23265 assertTrue(GrouperClientWs.mostRecentRequest,
23266 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23267 assertTrue(GrouperClientWs.mostRecentRequest,
23268 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23269 assertTrue(GrouperClientWs.mostRecentRequest,
23270 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23271 assertTrue(GrouperClientWs.mostRecentRequest,
23272 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23273 assertTrue(GrouperClientWs.mostRecentRequest,
23274 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23275 assertTrue(GrouperClientWs.mostRecentRequest,
23276 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23277 assertTrue(GrouperClientWs.mostRecentRequest,
23278 !GrouperClientWs.mostRecentRequest.contains("params"));
23279 assertTrue(GrouperClientWs.mostRecentRequest,
23280 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23281 assertTrue(GrouperClientWs.mostRecentRequest,
23282 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23283 assertFalse(GrouperClientWs.mostRecentRequest,
23284 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23285 assertTrue(GrouperClientWs.mostRecentRequest,
23286 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23287 assertTrue(GrouperClientWs.mostRecentRequest,
23288 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23289 assertTrue(GrouperClientWs.mostRecentRequest,
23290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23291 assertTrue(GrouperClientWs.mostRecentRequest,
23292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23293 assertTrue(GrouperClientWs.mostRecentRequest,
23294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23295 assertTrue(GrouperClientWs.mostRecentRequest,
23296 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23297 assertTrue(GrouperClientWs.mostRecentRequest,
23298 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23299 assertTrue(GrouperClientWs.mostRecentRequest,
23300 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23301 assertFalse(GrouperClientWs.mostRecentRequest,
23302 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23303 assertFalse(GrouperClientWs.mostRecentRequest,
23304 GrouperClientWs.mostRecentRequest.contains("theValue"));
23305 assertFalse(GrouperClientWs.mostRecentRequest,
23306 GrouperClientWs.mostRecentRequest.contains(">123<"));
23307 assertFalse(GrouperClientWs.mostRecentRequest,
23308 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23309 assertFalse(GrouperClientWs.mostRecentRequest,
23310 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23311 assertTrue(GrouperClientWs.mostRecentRequest,
23312 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23313 assertTrue(GrouperClientWs.mostRecentRequest,
23314 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23315 assertTrue(GrouperClientWs.mostRecentRequest,
23316 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23317 assertTrue(GrouperClientWs.mostRecentRequest,
23318 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23319 assertTrue(GrouperClientWs.mostRecentRequest,
23320 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23321 assertTrue(GrouperClientWs.mostRecentRequest,
23322 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23323
23324
23325
23326
23327
23328 baos = new ByteArrayOutputStream();
23329 System.setOut(new PrintStream(baos));
23330
23331 GrouperClient.main(GrouperClientUtils.splitTrim(
23332 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
23333 ,
23334 " "));
23335
23336 System.out.flush();
23337 output = new String(baos.toByteArray());
23338
23339 System.setOut(systemOut);
23340
23341 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23342
23343
23344
23345 pattern = Pattern
23346 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23347
23348 assertEquals(1, GrouperUtil.length(outputLines));
23349
23350 outputLine = outputLines[0];
23351
23352 matcher = pattern.matcher(outputLine);
23353
23354 assertTrue(outputLine, matcher.matches());
23355 assertEquals(outputLine, "0", matcher.group(1));
23356 assertEquals(outputLine, "group_asgn", matcher.group(2));
23357 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23358 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23359 assertEquals(outputLine, "assign", matcher.group(5));
23360 assertEquals(outputLine, "123", matcher.group(6));
23361 assertEquals(outputLine, "T", matcher.group(7));
23362 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23363
23364 assertTrue(GrouperClientWs.mostRecentRequest,
23365 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23366 assertTrue(GrouperClientWs.mostRecentRequest,
23367 !GrouperClientWs.mostRecentRequest.contains("actions"));
23368 assertTrue(GrouperClientWs.mostRecentRequest,
23369 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23370 assertTrue(GrouperClientWs.mostRecentRequest,
23371 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23372 assertTrue(GrouperClientWs.mostRecentRequest,
23373 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23374 assertTrue(GrouperClientWs.mostRecentRequest,
23375 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23376 assertTrue(GrouperClientWs.mostRecentRequest,
23377 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23378 assertTrue(GrouperClientWs.mostRecentRequest,
23379 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23380 assertTrue(GrouperClientWs.mostRecentRequest,
23381 !GrouperClientWs.mostRecentRequest.contains("params"));
23382 assertTrue(GrouperClientWs.mostRecentRequest,
23383 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23384 assertTrue(GrouperClientWs.mostRecentRequest,
23385 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23386 assertFalse(GrouperClientWs.mostRecentRequest,
23387 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23388 assertTrue(GrouperClientWs.mostRecentRequest,
23389 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23390 assertTrue(GrouperClientWs.mostRecentRequest,
23391 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23392 assertTrue(GrouperClientWs.mostRecentRequest,
23393 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23394 assertTrue(GrouperClientWs.mostRecentRequest,
23395 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23396 assertTrue(GrouperClientWs.mostRecentRequest,
23397 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23398 assertTrue(GrouperClientWs.mostRecentRequest,
23399 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23400 assertTrue(GrouperClientWs.mostRecentRequest,
23401 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23402 assertTrue(GrouperClientWs.mostRecentRequest,
23403 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23404 assertFalse(GrouperClientWs.mostRecentRequest,
23405 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23406 assertFalse(GrouperClientWs.mostRecentRequest,
23407 GrouperClientWs.mostRecentRequest.contains("theValue"));
23408 assertFalse(GrouperClientWs.mostRecentRequest,
23409 GrouperClientWs.mostRecentRequest.contains(">123<"));
23410 assertFalse(GrouperClientWs.mostRecentRequest,
23411 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23412 assertFalse(GrouperClientWs.mostRecentRequest,
23413 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23414 assertTrue(GrouperClientWs.mostRecentRequest,
23415 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23416 assertTrue(GrouperClientWs.mostRecentRequest,
23417 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23418 assertTrue(GrouperClientWs.mostRecentRequest,
23419 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23420 assertTrue(GrouperClientWs.mostRecentRequest,
23421 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23422 assertTrue(GrouperClientWs.mostRecentRequest,
23423 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23424 assertTrue(GrouperClientWs.mostRecentRequest,
23425 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23426
23427
23428
23429
23430
23431
23432 baos = new ByteArrayOutputStream();
23433 System.setOut(new PrintStream(baos));
23434
23435 try {
23436 GrouperClient.main(GrouperClientUtils.splitTrim(
23437 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
23438 ,
23439 " "));
23440
23441 System.out.flush();
23442 output = new String(baos.toByteArray());
23443
23444 System.setOut(systemOut);
23445
23446 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23447
23448
23449
23450 pattern = Pattern
23451 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23452
23453 assertEquals(0, GrouperUtil.length(outputLines));
23454 fail("Shouldnt get here");
23455 } catch (Exception e) {
23456
23457 } finally {
23458
23459 System.setOut(systemOut);
23460
23461 }
23462
23463 assertTrue(GrouperClientWs.mostRecentRequest,
23464 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23465 assertTrue(GrouperClientWs.mostRecentRequest,
23466 !GrouperClientWs.mostRecentRequest.contains("actions"));
23467 assertTrue(GrouperClientWs.mostRecentRequest,
23468 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23469 assertTrue(GrouperClientWs.mostRecentRequest,
23470 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23471 assertTrue(GrouperClientWs.mostRecentRequest,
23472 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23473 assertTrue(GrouperClientWs.mostRecentRequest,
23474 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23475 assertTrue(GrouperClientWs.mostRecentRequest,
23476 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23477 assertTrue(GrouperClientWs.mostRecentRequest,
23478 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23479 assertTrue(GrouperClientWs.mostRecentRequest,
23480 !GrouperClientWs.mostRecentRequest.contains("params"));
23481 assertTrue(GrouperClientWs.mostRecentRequest,
23482 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23483 assertTrue(GrouperClientWs.mostRecentRequest,
23484 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23485 assertFalse(GrouperClientWs.mostRecentRequest,
23486 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23487 assertTrue(GrouperClientWs.mostRecentRequest,
23488 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23489 assertTrue(GrouperClientWs.mostRecentRequest,
23490 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23491 assertTrue(GrouperClientWs.mostRecentRequest,
23492 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23493 assertTrue(GrouperClientWs.mostRecentRequest,
23494 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23495 assertTrue(GrouperClientWs.mostRecentRequest,
23496 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23497 assertTrue(GrouperClientWs.mostRecentRequest,
23498 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23499 assertTrue(GrouperClientWs.mostRecentRequest,
23500 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23501 assertTrue(GrouperClientWs.mostRecentRequest,
23502 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23503 assertFalse(GrouperClientWs.mostRecentRequest,
23504 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23505 assertFalse(GrouperClientWs.mostRecentRequest,
23506 GrouperClientWs.mostRecentRequest.contains("theValue"));
23507 assertFalse(GrouperClientWs.mostRecentRequest,
23508 GrouperClientWs.mostRecentRequest.contains(">123<"));
23509 assertFalse(GrouperClientWs.mostRecentRequest,
23510 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23511 assertFalse(GrouperClientWs.mostRecentRequest,
23512 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23513 assertTrue(GrouperClientWs.mostRecentRequest,
23514 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23515 assertTrue(GrouperClientWs.mostRecentRequest,
23516 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23517 assertTrue(GrouperClientWs.mostRecentRequest,
23518 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23519 assertTrue(GrouperClientWs.mostRecentRequest,
23520 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23521 assertTrue(GrouperClientWs.mostRecentRequest,
23522 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23523 assertTrue(GrouperClientWs.mostRecentRequest,
23524 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23525
23526
23527
23528
23529
23530 baos = new ByteArrayOutputStream();
23531 System.setOut(new PrintStream(baos));
23532
23533 GrouperClient.main(GrouperClientUtils.splitTrim(
23534 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
23535 ,
23536 " "));
23537
23538 System.out.flush();
23539 output = new String(baos.toByteArray());
23540
23541 System.setOut(systemOut);
23542
23543 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23544
23545
23546
23547 pattern = Pattern
23548 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23549
23550 assertEquals(1, GrouperUtil.length(outputLines));
23551
23552 outputLine = outputLines[0];
23553
23554 matcher = pattern.matcher(outputLine);
23555
23556 assertTrue(outputLine, matcher.matches());
23557 assertEquals(outputLine, "0", matcher.group(1));
23558 assertEquals(outputLine, "group_asgn", matcher.group(2));
23559 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23560 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23561 assertEquals(outputLine, "assign", matcher.group(5));
23562 assertEquals(outputLine, "123", matcher.group(6));
23563 assertEquals(outputLine, "T", matcher.group(7));
23564 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23565
23566 assertTrue(GrouperClientWs.mostRecentRequest,
23567 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23568 assertTrue(GrouperClientWs.mostRecentRequest,
23569 !GrouperClientWs.mostRecentRequest.contains("actions"));
23570 assertTrue(GrouperClientWs.mostRecentRequest,
23571 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23572 assertTrue(GrouperClientWs.mostRecentRequest,
23573 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23574 assertTrue(GrouperClientWs.mostRecentRequest,
23575 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23576 assertTrue(GrouperClientWs.mostRecentRequest,
23577 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23578 assertTrue(GrouperClientWs.mostRecentRequest,
23579 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23580 assertTrue(GrouperClientWs.mostRecentRequest,
23581 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23582 assertTrue(GrouperClientWs.mostRecentRequest,
23583 !GrouperClientWs.mostRecentRequest.contains("params"));
23584 assertTrue(GrouperClientWs.mostRecentRequest,
23585 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23586 assertTrue(GrouperClientWs.mostRecentRequest,
23587 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23588 assertFalse(GrouperClientWs.mostRecentRequest,
23589 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23590 assertFalse(GrouperClientWs.mostRecentRequest,
23591 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23592 assertTrue(GrouperClientWs.mostRecentRequest,
23593 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23594 assertTrue(GrouperClientWs.mostRecentRequest,
23595 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23596 assertTrue(GrouperClientWs.mostRecentRequest,
23597 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23598 assertTrue(GrouperClientWs.mostRecentRequest,
23599 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23600 assertTrue(GrouperClientWs.mostRecentRequest,
23601 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23602 assertTrue(GrouperClientWs.mostRecentRequest,
23603 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23604 assertTrue(GrouperClientWs.mostRecentRequest,
23605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23606 assertFalse(GrouperClientWs.mostRecentRequest,
23607 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23608 assertFalse(GrouperClientWs.mostRecentRequest,
23609 GrouperClientWs.mostRecentRequest.contains("theValue"));
23610 assertFalse(GrouperClientWs.mostRecentRequest,
23611 GrouperClientWs.mostRecentRequest.contains(">123<"));
23612 assertFalse(GrouperClientWs.mostRecentRequest,
23613 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23614 assertFalse(GrouperClientWs.mostRecentRequest,
23615 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23616 assertTrue(GrouperClientWs.mostRecentRequest,
23617 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23618 assertTrue(GrouperClientWs.mostRecentRequest,
23619 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23620 assertTrue(GrouperClientWs.mostRecentRequest,
23621 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23622 assertTrue(GrouperClientWs.mostRecentRequest,
23623 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23624
23625
23626
23627
23628
23629
23630 baos = new ByteArrayOutputStream();
23631 System.setOut(new PrintStream(baos));
23632
23633 try {
23634 GrouperClient.main(GrouperClientUtils.splitTrim(
23635 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
23636 ,
23637 " "));
23638
23639 System.out.flush();
23640 output = new String(baos.toByteArray());
23641
23642 System.setOut(systemOut);
23643
23644 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23645
23646
23647
23648 pattern = Pattern
23649 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23650
23651 assertEquals(0, GrouperUtil.length(outputLines));
23652 fail("Shouldnt get here");
23653
23654 } catch (Exception e) {
23655
23656 } finally {
23657
23658 System.setOut(systemOut);
23659
23660 }
23661
23662 assertTrue(GrouperClientWs.mostRecentRequest,
23663 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23664 assertTrue(GrouperClientWs.mostRecentRequest,
23665 !GrouperClientWs.mostRecentRequest.contains("actions"));
23666 assertTrue(GrouperClientWs.mostRecentRequest,
23667 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23668 assertTrue(GrouperClientWs.mostRecentRequest,
23669 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23670 assertTrue(GrouperClientWs.mostRecentRequest,
23671 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23672 assertTrue(GrouperClientWs.mostRecentRequest,
23673 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23674 assertTrue(GrouperClientWs.mostRecentRequest,
23675 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23676 assertTrue(GrouperClientWs.mostRecentRequest,
23677 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23678 assertTrue(GrouperClientWs.mostRecentRequest,
23679 !GrouperClientWs.mostRecentRequest.contains("params"));
23680 assertTrue(GrouperClientWs.mostRecentRequest,
23681 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23682 assertTrue(GrouperClientWs.mostRecentRequest,
23683 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23684 assertFalse(GrouperClientWs.mostRecentRequest,
23685 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23686 assertFalse(GrouperClientWs.mostRecentRequest,
23687 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23688 assertTrue(GrouperClientWs.mostRecentRequest,
23689 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23690 assertTrue(GrouperClientWs.mostRecentRequest,
23691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23692 assertTrue(GrouperClientWs.mostRecentRequest,
23693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23694 assertTrue(GrouperClientWs.mostRecentRequest,
23695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23696 assertTrue(GrouperClientWs.mostRecentRequest,
23697 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23698 assertTrue(GrouperClientWs.mostRecentRequest,
23699 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23700 assertTrue(GrouperClientWs.mostRecentRequest,
23701 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23702 assertFalse(GrouperClientWs.mostRecentRequest,
23703 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23704 assertFalse(GrouperClientWs.mostRecentRequest,
23705 GrouperClientWs.mostRecentRequest.contains("theValue"));
23706 assertFalse(GrouperClientWs.mostRecentRequest,
23707 GrouperClientWs.mostRecentRequest.contains(">123<"));
23708 assertFalse(GrouperClientWs.mostRecentRequest,
23709 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23710 assertFalse(GrouperClientWs.mostRecentRequest,
23711 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23712 assertTrue(GrouperClientWs.mostRecentRequest,
23713 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23714 assertTrue(GrouperClientWs.mostRecentRequest,
23715 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23716 assertTrue(GrouperClientWs.mostRecentRequest,
23717 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23718 assertTrue(GrouperClientWs.mostRecentRequest,
23719 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23720
23721
23722
23723
23724
23725 baos = new ByteArrayOutputStream();
23726 System.setOut(new PrintStream(baos));
23727
23728 GrouperClient.main(GrouperClientUtils.splitTrim(
23729 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
23730 ,
23731 " "));
23732
23733 System.out.flush();
23734 output = new String(baos.toByteArray());
23735
23736 System.setOut(systemOut);
23737
23738 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23739
23740
23741
23742 pattern = Pattern
23743 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23744
23745 assertEquals(1, GrouperUtil.length(outputLines));
23746
23747 outputLine = outputLines[0];
23748
23749 matcher = pattern.matcher(outputLine);
23750
23751 assertTrue(outputLine, matcher.matches());
23752 assertEquals(outputLine, "0", matcher.group(1));
23753 assertEquals(outputLine, "group_asgn", matcher.group(2));
23754 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23755 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23756 assertEquals(outputLine, "assign", matcher.group(5));
23757 assertEquals(outputLine, "123", matcher.group(6));
23758 assertEquals(outputLine, "T", matcher.group(7));
23759 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23760
23761 assertTrue(GrouperClientWs.mostRecentRequest,
23762 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23763 assertTrue(GrouperClientWs.mostRecentRequest,
23764 !GrouperClientWs.mostRecentRequest.contains("actions"));
23765 assertTrue(GrouperClientWs.mostRecentRequest,
23766 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23767 assertTrue(GrouperClientWs.mostRecentRequest,
23768 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23769 assertTrue(GrouperClientWs.mostRecentRequest,
23770 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23771 assertTrue(GrouperClientWs.mostRecentRequest,
23772 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23773 assertTrue(GrouperClientWs.mostRecentRequest,
23774 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23775 assertTrue(GrouperClientWs.mostRecentRequest,
23776 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23777 assertTrue(GrouperClientWs.mostRecentRequest,
23778 !GrouperClientWs.mostRecentRequest.contains("params"));
23779 assertTrue(GrouperClientWs.mostRecentRequest,
23780 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23781 assertTrue(GrouperClientWs.mostRecentRequest,
23782 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23783 assertFalse(GrouperClientWs.mostRecentRequest,
23784 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23785 assertTrue(GrouperClientWs.mostRecentRequest,
23786 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23787 assertTrue(GrouperClientWs.mostRecentRequest,
23788 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23789 assertTrue(GrouperClientWs.mostRecentRequest,
23790 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23791 assertTrue(GrouperClientWs.mostRecentRequest,
23792 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23793 assertTrue(GrouperClientWs.mostRecentRequest,
23794 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23795 assertTrue(GrouperClientWs.mostRecentRequest,
23796 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23797 assertTrue(GrouperClientWs.mostRecentRequest,
23798 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23799 assertTrue(GrouperClientWs.mostRecentRequest,
23800 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23801 assertFalse(GrouperClientWs.mostRecentRequest,
23802 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23803 assertFalse(GrouperClientWs.mostRecentRequest,
23804 GrouperClientWs.mostRecentRequest.contains("theValue"));
23805 assertFalse(GrouperClientWs.mostRecentRequest,
23806 GrouperClientWs.mostRecentRequest.contains(">123<"));
23807 assertFalse(GrouperClientWs.mostRecentRequest,
23808 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23809 assertFalse(GrouperClientWs.mostRecentRequest,
23810 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23811 assertTrue(GrouperClientWs.mostRecentRequest,
23812 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23813 assertTrue(GrouperClientWs.mostRecentRequest,
23814 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23815 assertTrue(GrouperClientWs.mostRecentRequest,
23816 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23817 assertTrue(GrouperClientWs.mostRecentRequest,
23818 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23819
23820
23821
23822
23823
23824
23825 baos = new ByteArrayOutputStream();
23826 System.setOut(new PrintStream(baos));
23827
23828 try {
23829 GrouperClient.main(GrouperClientUtils.splitTrim(
23830 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
23831 ,
23832 " "));
23833
23834 System.out.flush();
23835 output = new String(baos.toByteArray());
23836
23837 System.setOut(systemOut);
23838
23839 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23840
23841
23842
23843 pattern = Pattern
23844 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23845
23846 assertEquals(1, GrouperUtil.length(outputLines));
23847 fail("Shouldnt get here");
23848 } catch (Exception e) {
23849
23850 } finally {
23851
23852 System.setOut(systemOut);
23853
23854 }
23855
23856 assertTrue(GrouperClientWs.mostRecentRequest,
23857 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23858 assertTrue(GrouperClientWs.mostRecentRequest,
23859 !GrouperClientWs.mostRecentRequest.contains("actions"));
23860 assertTrue(GrouperClientWs.mostRecentRequest,
23861 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23862 assertTrue(GrouperClientWs.mostRecentRequest,
23863 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23864 assertTrue(GrouperClientWs.mostRecentRequest,
23865 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23866 assertTrue(GrouperClientWs.mostRecentRequest,
23867 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23868 assertTrue(GrouperClientWs.mostRecentRequest,
23869 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23870 assertTrue(GrouperClientWs.mostRecentRequest,
23871 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23872 assertTrue(GrouperClientWs.mostRecentRequest,
23873 !GrouperClientWs.mostRecentRequest.contains("params"));
23874 assertTrue(GrouperClientWs.mostRecentRequest,
23875 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23876 assertTrue(GrouperClientWs.mostRecentRequest,
23877 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23878 assertFalse(GrouperClientWs.mostRecentRequest,
23879 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23880 assertTrue(GrouperClientWs.mostRecentRequest,
23881 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23882 assertTrue(GrouperClientWs.mostRecentRequest,
23883 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23884 assertTrue(GrouperClientWs.mostRecentRequest,
23885 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23886 assertTrue(GrouperClientWs.mostRecentRequest,
23887 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23888 assertTrue(GrouperClientWs.mostRecentRequest,
23889 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23890 assertTrue(GrouperClientWs.mostRecentRequest,
23891 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23892 assertTrue(GrouperClientWs.mostRecentRequest,
23893 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23894 assertTrue(GrouperClientWs.mostRecentRequest,
23895 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23896 assertFalse(GrouperClientWs.mostRecentRequest,
23897 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23898 assertFalse(GrouperClientWs.mostRecentRequest,
23899 GrouperClientWs.mostRecentRequest.contains("theValue"));
23900 assertFalse(GrouperClientWs.mostRecentRequest,
23901 GrouperClientWs.mostRecentRequest.contains(">123<"));
23902 assertFalse(GrouperClientWs.mostRecentRequest,
23903 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23904 assertFalse(GrouperClientWs.mostRecentRequest,
23905 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23906 assertTrue(GrouperClientWs.mostRecentRequest,
23907 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23908 assertTrue(GrouperClientWs.mostRecentRequest,
23909 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23910 assertTrue(GrouperClientWs.mostRecentRequest,
23911 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23912 assertTrue(GrouperClientWs.mostRecentRequest,
23913 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23914
23915
23916
23917
23918
23919 baos = new ByteArrayOutputStream();
23920 System.setOut(new PrintStream(baos));
23921
23922 GrouperClient.main(GrouperClientUtils.splitTrim(
23923 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
23924 + " --assignAssignOwnerActions=assign",
23925 " "));
23926
23927 System.out.flush();
23928 output = new String(baos.toByteArray());
23929
23930 System.setOut(systemOut);
23931
23932 outputLines = GrouperClientUtils.splitTrim(output, "\n");
23933
23934
23935
23936 pattern = Pattern
23937 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23938
23939 assertEquals(1, GrouperUtil.length(outputLines));
23940
23941 outputLine = outputLines[0];
23942
23943 matcher = pattern.matcher(outputLine);
23944
23945 assertTrue(outputLine, matcher.matches());
23946 assertEquals(outputLine, "0", matcher.group(1));
23947 assertEquals(outputLine, "group_asgn", matcher.group(2));
23948 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23949 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23950 assertEquals(outputLine, "assign", matcher.group(5));
23951 assertEquals(outputLine, "123", matcher.group(6));
23952 assertEquals(outputLine, "T", matcher.group(7));
23953 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23954
23955 assertTrue(GrouperClientWs.mostRecentRequest,
23956 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23957 assertTrue(GrouperClientWs.mostRecentRequest,
23958 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
23959 assertTrue(GrouperClientWs.mostRecentRequest,
23960 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23961 assertTrue(GrouperClientWs.mostRecentRequest,
23962 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23963 assertTrue(GrouperClientWs.mostRecentRequest,
23964 !GrouperClientWs.mostRecentRequest.contains("enabled"));
23965 assertTrue(GrouperClientWs.mostRecentRequest,
23966 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23967 assertTrue(GrouperClientWs.mostRecentRequest,
23968 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23969 assertTrue(GrouperClientWs.mostRecentRequest,
23970 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23971 assertTrue(GrouperClientWs.mostRecentRequest,
23972 !GrouperClientWs.mostRecentRequest.contains("params"));
23973 assertTrue(GrouperClientWs.mostRecentRequest,
23974 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23975 assertTrue(GrouperClientWs.mostRecentRequest,
23976 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23977 assertFalse(GrouperClientWs.mostRecentRequest,
23978 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23979 assertTrue(GrouperClientWs.mostRecentRequest,
23980 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23981 assertTrue(GrouperClientWs.mostRecentRequest,
23982 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23983 assertTrue(GrouperClientWs.mostRecentRequest,
23984 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23985 assertTrue(GrouperClientWs.mostRecentRequest,
23986 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23987 assertTrue(GrouperClientWs.mostRecentRequest,
23988 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23989 assertTrue(GrouperClientWs.mostRecentRequest,
23990 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23991 assertTrue(GrouperClientWs.mostRecentRequest,
23992 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23993 assertTrue(GrouperClientWs.mostRecentRequest,
23994 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23995 assertFalse(GrouperClientWs.mostRecentRequest,
23996 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23997 assertFalse(GrouperClientWs.mostRecentRequest,
23998 GrouperClientWs.mostRecentRequest.contains("theValue"));
23999 assertFalse(GrouperClientWs.mostRecentRequest,
24000 GrouperClientWs.mostRecentRequest.contains(">123<"));
24001 assertFalse(GrouperClientWs.mostRecentRequest,
24002 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24003 assertFalse(GrouperClientWs.mostRecentRequest,
24004 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24005 assertTrue(GrouperClientWs.mostRecentRequest,
24006 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24007 assertTrue(GrouperClientWs.mostRecentRequest,
24008 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24009 assertTrue(GrouperClientWs.mostRecentRequest,
24010 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24011 assertTrue(GrouperClientWs.mostRecentRequest,
24012 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
24013
24014
24015
24016
24017
24018 baos = new ByteArrayOutputStream();
24019 System.setOut(new PrintStream(baos));
24020
24021 GrouperClient.main(GrouperClientUtils.splitTrim(
24022 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
24023 + " --assignAssignOwnerActions=assign2",
24024 " "));
24025
24026 System.out.flush();
24027 output = new String(baos.toByteArray());
24028
24029 System.setOut(systemOut);
24030
24031 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24032
24033
24034
24035 pattern = Pattern
24036 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24037
24038 assertEquals(0, GrouperUtil.length(outputLines));
24039
24040 assertTrue(GrouperClientWs.mostRecentRequest,
24041 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24042 assertTrue(GrouperClientWs.mostRecentRequest,
24043 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
24044 assertTrue(GrouperClientWs.mostRecentRequest,
24045 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24046 assertTrue(GrouperClientWs.mostRecentRequest,
24047 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24048 assertTrue(GrouperClientWs.mostRecentRequest,
24049 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24050 assertTrue(GrouperClientWs.mostRecentRequest,
24051 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24052 assertTrue(GrouperClientWs.mostRecentRequest,
24053 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24054 assertTrue(GrouperClientWs.mostRecentRequest,
24055 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24056 assertTrue(GrouperClientWs.mostRecentRequest,
24057 !GrouperClientWs.mostRecentRequest.contains("params"));
24058 assertTrue(GrouperClientWs.mostRecentRequest,
24059 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24060 assertTrue(GrouperClientWs.mostRecentRequest,
24061 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24062 assertFalse(GrouperClientWs.mostRecentRequest,
24063 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
24064 assertTrue(GrouperClientWs.mostRecentRequest,
24065 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24066 assertTrue(GrouperClientWs.mostRecentRequest,
24067 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24068 assertTrue(GrouperClientWs.mostRecentRequest,
24069 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24070 assertTrue(GrouperClientWs.mostRecentRequest,
24071 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24072 assertTrue(GrouperClientWs.mostRecentRequest,
24073 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24074 assertTrue(GrouperClientWs.mostRecentRequest,
24075 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24076 assertTrue(GrouperClientWs.mostRecentRequest,
24077 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24078 assertTrue(GrouperClientWs.mostRecentRequest,
24079 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24080 assertFalse(GrouperClientWs.mostRecentRequest,
24081 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24082 assertFalse(GrouperClientWs.mostRecentRequest,
24083 GrouperClientWs.mostRecentRequest.contains("theValue"));
24084 assertFalse(GrouperClientWs.mostRecentRequest,
24085 GrouperClientWs.mostRecentRequest.contains(">123<"));
24086 assertFalse(GrouperClientWs.mostRecentRequest,
24087 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24088 assertFalse(GrouperClientWs.mostRecentRequest,
24089 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24090 assertTrue(GrouperClientWs.mostRecentRequest,
24091 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24092 assertTrue(GrouperClientWs.mostRecentRequest,
24093 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24094 assertTrue(GrouperClientWs.mostRecentRequest,
24095 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24096 assertTrue(GrouperClientWs.mostRecentRequest,
24097 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
24098
24099
24100
24101
24102
24103
24104 baos = new ByteArrayOutputStream();
24105 System.setOut(new PrintStream(baos));
24106
24107 GrouperClient.main(GrouperClientUtils.splitTrim(
24108 "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --ownerGroupNames=" + group.getName()
24109 ,
24110 " "));
24111
24112 System.out.flush();
24113 output = new String(baos.toByteArray());
24114
24115 System.setOut(systemOut);
24116
24117 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24118
24119
24120
24121 pattern = Pattern
24122 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24123
24124 assertEquals(1, GrouperUtil.length(outputLines));
24125
24126 outputLine = outputLines[0];
24127
24128 matcher = pattern.matcher(outputLine);
24129
24130 assertTrue(outputLine, matcher.matches());
24131 assertEquals(outputLine, "0", matcher.group(1));
24132 assertEquals(outputLine, "group_asgn", matcher.group(2));
24133 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
24134 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
24135 assertEquals(outputLine, "assign", matcher.group(5));
24136 assertEquals(outputLine, "123", matcher.group(6));
24137 assertEquals(outputLine, "T", matcher.group(7));
24138 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
24139
24140 assertTrue(GrouperClientWs.mostRecentRequest,
24141 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24142 assertTrue(GrouperClientWs.mostRecentRequest,
24143 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
24144 assertTrue(GrouperClientWs.mostRecentRequest,
24145 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24146 assertTrue(GrouperClientWs.mostRecentRequest,
24147 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24148 assertTrue(GrouperClientWs.mostRecentRequest,
24149 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24150 assertTrue(GrouperClientWs.mostRecentRequest,
24151 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24152 assertTrue(GrouperClientWs.mostRecentRequest,
24153 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24154 assertTrue(GrouperClientWs.mostRecentRequest,
24155 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24156 assertTrue(GrouperClientWs.mostRecentRequest,
24157 !GrouperClientWs.mostRecentRequest.contains("params"));
24158 assertTrue(GrouperClientWs.mostRecentRequest,
24159 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24160 assertTrue(GrouperClientWs.mostRecentRequest,
24161 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24162 assertFalse(GrouperClientWs.mostRecentRequest,
24163 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
24164 assertFalse(GrouperClientWs.mostRecentRequest,
24165 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24166 assertTrue(GrouperClientWs.mostRecentRequest,
24167 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24168 assertTrue(GrouperClientWs.mostRecentRequest,
24169 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24170 assertTrue(GrouperClientWs.mostRecentRequest,
24171 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24172 assertTrue(GrouperClientWs.mostRecentRequest,
24173 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24174 assertTrue(GrouperClientWs.mostRecentRequest,
24175 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24176 assertTrue(GrouperClientWs.mostRecentRequest,
24177 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24178 assertTrue(GrouperClientWs.mostRecentRequest,
24179 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24180 assertFalse(GrouperClientWs.mostRecentRequest,
24181 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24182 assertFalse(GrouperClientWs.mostRecentRequest,
24183 GrouperClientWs.mostRecentRequest.contains("theValue"));
24184 assertFalse(GrouperClientWs.mostRecentRequest,
24185 GrouperClientWs.mostRecentRequest.contains(">123<"));
24186 assertFalse(GrouperClientWs.mostRecentRequest,
24187 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24188 assertFalse(GrouperClientWs.mostRecentRequest,
24189 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24190 assertTrue(GrouperClientWs.mostRecentRequest,
24191 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24192 assertTrue(GrouperClientWs.mostRecentRequest,
24193 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24194 assertTrue(GrouperClientWs.mostRecentRequest,
24195 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24196 assertTrue(GrouperClientWs.mostRecentRequest,
24197 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
24198
24199
24200 } finally {
24201 System.setOut(systemOut);
24202 }
24203
24204 }
24205
24206
24207
24208
24209 public void testGetAttributeAssignsStemExtraFeatures() throws Exception {
24210
24211 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
24212 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
24213
24214 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
24215
24216 attributeDef.setValueType(AttributeDefValueType.string);
24217 attributeDef.setAssignToStem(true);
24218 attributeDef.store();
24219
24220 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
24221
24222 attributeDef2.setAssignToGroup(false);
24223 attributeDef2.setAssignToStemAssn(true);
24224 attributeDef2.setValueType(AttributeDefValueType.integer);
24225 attributeDef2.store();
24226
24227 Stem stem = new StemSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
24228 .assignName("test:stemTestAttrAssign").assignCreateParentStemsIfNotExist(true)
24229 .assignDescription("description").save();
24230
24231 AttributeAssignResult attributeAssignResult = stem.getAttributeDelegate().assignAttribute(attributeDefName);
24232 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
24233 attributeAssign.getValueDelegate().assignValue("abc");
24234
24235 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
24236 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
24237 attributeAssign2.getValueDelegate().assignValue("123");
24238
24239 PrintStream systemOut = System.out;
24240
24241 ByteArrayOutputStream baos = new ByteArrayOutputStream();
24242 System.setOut(new PrintStream(baos));
24243
24244 try {
24245
24246 GrouperClient.main(GrouperClientUtils.splitTrim(
24247 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem " +
24248 "--attributeDefNames=test:testAttributeAssignDefNameDef " +
24249 "--attributeDefValueType=string --value=abc",
24250 " "));
24251 System.out.flush();
24252 String output = new String(baos.toByteArray());
24253
24254 System.setOut(systemOut);
24255
24256 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
24257
24258
24259
24260 Pattern pattern = Pattern
24261 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24262
24263 assertEquals(1, GrouperUtil.length(outputLines));
24264 String outputLine = outputLines[0];
24265
24266 Matcher matcher = pattern.matcher(outputLines[0]);
24267
24268 assertTrue(outputLine, matcher.matches());
24269 assertEquals(outputLine, "0", matcher.group(1));
24270 assertEquals(outputLine, "stem", matcher.group(2));
24271 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
24272 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
24273 assertEquals(outputLine, "assign", matcher.group(5));
24274 assertEquals(outputLine, "abc", matcher.group(6));
24275 assertEquals(outputLine, "T", matcher.group(7));
24276 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
24277
24278 assertTrue(GrouperClientWs.mostRecentRequest,
24279 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24280 assertTrue(GrouperClientWs.mostRecentRequest,
24281 !GrouperClientWs.mostRecentRequest.contains("actions"));
24282 assertTrue(GrouperClientWs.mostRecentRequest,
24283 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24284 assertTrue(GrouperClientWs.mostRecentRequest,
24285 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24286 assertTrue(GrouperClientWs.mostRecentRequest,
24287 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24288 assertTrue(GrouperClientWs.mostRecentRequest,
24289 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24290 assertTrue(GrouperClientWs.mostRecentRequest,
24291 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24292 assertTrue(GrouperClientWs.mostRecentRequest,
24293 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24294 assertTrue(GrouperClientWs.mostRecentRequest,
24295 !GrouperClientWs.mostRecentRequest.contains("params"));
24296 assertTrue(GrouperClientWs.mostRecentRequest,
24297 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24298 assertTrue(GrouperClientWs.mostRecentRequest,
24299 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24300 assertTrue(GrouperClientWs.mostRecentRequest,
24301 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
24302 assertTrue(GrouperClientWs.mostRecentRequest,
24303 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24304 assertTrue(GrouperClientWs.mostRecentRequest,
24305 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24306 assertTrue(GrouperClientWs.mostRecentRequest,
24307 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24308 assertTrue(GrouperClientWs.mostRecentRequest,
24309 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24310 assertTrue(GrouperClientWs.mostRecentRequest,
24311 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24312 assertTrue(GrouperClientWs.mostRecentRequest,
24313 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24314 assertTrue(GrouperClientWs.mostRecentRequest,
24315 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24316 assertTrue(GrouperClientWs.mostRecentRequest,
24317 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24318 assertTrue(GrouperClientWs.mostRecentRequest,
24319 GrouperClientWs.mostRecentRequest.contains("theValue"));
24320 assertTrue(GrouperClientWs.mostRecentRequest,
24321 GrouperClientWs.mostRecentRequest.contains("abc"));
24322 assertTrue(GrouperClientWs.mostRecentRequest,
24323 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24324 assertTrue(GrouperClientWs.mostRecentRequest,
24325 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24326 assertTrue(GrouperClientWs.mostRecentRequest,
24327 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24328 assertTrue(GrouperClientWs.mostRecentRequest,
24329 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24330 assertTrue(GrouperClientWs.mostRecentRequest,
24331 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24332 assertTrue(GrouperClientWs.mostRecentRequest,
24333 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24334 assertTrue(GrouperClientWs.mostRecentRequest,
24335 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24336 assertTrue(GrouperClientWs.mostRecentRequest,
24337 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24338
24339
24340
24341
24342 baos = new ByteArrayOutputStream();
24343 System.setOut(new PrintStream(baos));
24344
24345 GrouperClient.main(GrouperClientUtils.splitTrim(
24346 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=" + attributeDef.getId() +
24347 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
24348 "--attributeDefValueType=string --value=123",
24349 " "));
24350
24351
24352 System.out.flush();
24353 output = new String(baos.toByteArray());
24354
24355 System.setOut(systemOut);
24356
24357 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24358
24359 assertEquals(0, GrouperUtil.length(outputLines));
24360
24361
24362
24363
24364 assertTrue(GrouperClientWs.mostRecentRequest,
24365 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24366 assertTrue(GrouperClientWs.mostRecentRequest,
24367 !GrouperClientWs.mostRecentRequest.contains("actions"));
24368 assertTrue(GrouperClientWs.mostRecentRequest,
24369 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24370 assertTrue(GrouperClientWs.mostRecentRequest,
24371 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24372 assertTrue(GrouperClientWs.mostRecentRequest,
24373 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24374 assertTrue(GrouperClientWs.mostRecentRequest,
24375 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24376 assertTrue(GrouperClientWs.mostRecentRequest,
24377 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24378 assertTrue(GrouperClientWs.mostRecentRequest,
24379 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24380 assertTrue(GrouperClientWs.mostRecentRequest,
24381 !GrouperClientWs.mostRecentRequest.contains("params"));
24382 assertTrue(GrouperClientWs.mostRecentRequest,
24383 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24384 assertTrue(GrouperClientWs.mostRecentRequest,
24385 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24386 assertTrue(GrouperClientWs.mostRecentRequest,
24387 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
24388 assertTrue(GrouperClientWs.mostRecentRequest,
24389 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24390 assertTrue(GrouperClientWs.mostRecentRequest,
24391 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24392 assertTrue(GrouperClientWs.mostRecentRequest,
24393 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24394 assertTrue(GrouperClientWs.mostRecentRequest,
24395 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24396 assertTrue(GrouperClientWs.mostRecentRequest,
24397 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24398 assertTrue(GrouperClientWs.mostRecentRequest,
24399 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24400 assertTrue(GrouperClientWs.mostRecentRequest,
24401 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24402 assertTrue(GrouperClientWs.mostRecentRequest,
24403 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24404 assertTrue(GrouperClientWs.mostRecentRequest,
24405 GrouperClientWs.mostRecentRequest.contains("theValue"));
24406 assertTrue(GrouperClientWs.mostRecentRequest,
24407 GrouperClientWs.mostRecentRequest.contains(">123<"));
24408 assertTrue(GrouperClientWs.mostRecentRequest,
24409 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24410 assertTrue(GrouperClientWs.mostRecentRequest,
24411 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24412 assertTrue(GrouperClientWs.mostRecentRequest,
24413 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24414 assertTrue(GrouperClientWs.mostRecentRequest,
24415 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24416 assertTrue(GrouperClientWs.mostRecentRequest,
24417 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24418 assertTrue(GrouperClientWs.mostRecentRequest,
24419 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24420 assertTrue(GrouperClientWs.mostRecentRequest,
24421 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24422 assertTrue(GrouperClientWs.mostRecentRequest,
24423 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24424
24425
24426
24427
24428
24429 baos = new ByteArrayOutputStream();
24430 System.setOut(new PrintStream(baos));
24431
24432 try {
24433 GrouperClient.main(GrouperClientUtils.splitTrim(
24434 " --operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=123" + attributeDef.getId() +
24435 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
24436 "--attributeDefValueType=string --value=123",
24437 " "));
24438 fail("Shouldnt get here");
24439 } catch (GcWebServiceError gwse) {
24440
24441 }
24442
24443
24444
24445
24446 baos = new ByteArrayOutputStream();
24447 System.setOut(new PrintStream(baos));
24448
24449 GrouperClient.main(GrouperClientUtils.splitTrim(
24450 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=" + attributeDef.getId() +
24451 " --attributeDefValueType=string --value=abc --attributeDefType=attr",
24452 " "));
24453
24454
24455 System.out.flush();
24456 output = new String(baos.toByteArray());
24457
24458 System.setOut(systemOut);
24459
24460 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24461
24462
24463
24464 pattern = Pattern
24465 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24466
24467 assertEquals(1, GrouperUtil.length(outputLines));
24468 outputLine = outputLines[0];
24469
24470 matcher = pattern.matcher(outputLines[0]);
24471
24472 assertTrue(outputLine, matcher.matches());
24473 assertEquals(outputLine, "0", matcher.group(1));
24474 assertEquals(outputLine, "stem", matcher.group(2));
24475 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
24476 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
24477 assertEquals(outputLine, "assign", matcher.group(5));
24478 assertEquals(outputLine, "abc", matcher.group(6));
24479 assertEquals(outputLine, "T", matcher.group(7));
24480 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
24481
24482 assertTrue(GrouperClientWs.mostRecentRequest,
24483 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24484 assertTrue(GrouperClientWs.mostRecentRequest,
24485 !GrouperClientWs.mostRecentRequest.contains("actions"));
24486 assertTrue(GrouperClientWs.mostRecentRequest,
24487 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24488 assertTrue(GrouperClientWs.mostRecentRequest,
24489 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24490 assertTrue(GrouperClientWs.mostRecentRequest,
24491 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24492 assertTrue(GrouperClientWs.mostRecentRequest,
24493 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24494 assertTrue(GrouperClientWs.mostRecentRequest,
24495 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24496 assertTrue(GrouperClientWs.mostRecentRequest,
24497 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24498 assertTrue(GrouperClientWs.mostRecentRequest,
24499 !GrouperClientWs.mostRecentRequest.contains("params"));
24500 assertTrue(GrouperClientWs.mostRecentRequest,
24501 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24502 assertTrue(GrouperClientWs.mostRecentRequest,
24503 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24504 assertTrue(GrouperClientWs.mostRecentRequest,
24505 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24506 assertTrue(GrouperClientWs.mostRecentRequest,
24507 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24508 assertTrue(GrouperClientWs.mostRecentRequest,
24509 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24510 assertTrue(GrouperClientWs.mostRecentRequest,
24511 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24512 assertTrue(GrouperClientWs.mostRecentRequest,
24513 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24514 assertTrue(GrouperClientWs.mostRecentRequest,
24515 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24516 assertTrue(GrouperClientWs.mostRecentRequest,
24517 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24518 assertTrue(GrouperClientWs.mostRecentRequest,
24519 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24520 assertTrue(GrouperClientWs.mostRecentRequest,
24521 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24522 assertTrue(GrouperClientWs.mostRecentRequest,
24523 GrouperClientWs.mostRecentRequest.contains("theValue"));
24524 assertTrue(GrouperClientWs.mostRecentRequest,
24525 GrouperClientWs.mostRecentRequest.contains("abc"));
24526 assertTrue(GrouperClientWs.mostRecentRequest,
24527 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24528 assertTrue(GrouperClientWs.mostRecentRequest,
24529 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24530 assertTrue(GrouperClientWs.mostRecentRequest,
24531 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24532 assertTrue(GrouperClientWs.mostRecentRequest,
24533 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24534 assertTrue(GrouperClientWs.mostRecentRequest,
24535 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24536 assertTrue(GrouperClientWs.mostRecentRequest,
24537 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24538 assertTrue(GrouperClientWs.mostRecentRequest,
24539 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24540 assertTrue(GrouperClientWs.mostRecentRequest,
24541 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24542
24543
24544
24545
24546 baos = new ByteArrayOutputStream();
24547 System.setOut(new PrintStream(baos));
24548
24549 GrouperClient.main(GrouperClientUtils.splitTrim(
24550 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=" + attributeDef.getId() +
24551 " --attributeDefValueType=string --value=abc --attributeDefType=limit",
24552 " "));
24553
24554 System.out.flush();
24555 output = new String(baos.toByteArray());
24556
24557 System.setOut(systemOut);
24558
24559 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24560
24561
24562
24563 pattern = Pattern
24564 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24565
24566 assertEquals(0, GrouperUtil.length(outputLines));
24567
24568 assertTrue(GrouperClientWs.mostRecentRequest,
24569 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24570 assertTrue(GrouperClientWs.mostRecentRequest,
24571 !GrouperClientWs.mostRecentRequest.contains("actions"));
24572 assertTrue(GrouperClientWs.mostRecentRequest,
24573 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24574 assertTrue(GrouperClientWs.mostRecentRequest,
24575 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24576 assertTrue(GrouperClientWs.mostRecentRequest,
24577 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24578 assertTrue(GrouperClientWs.mostRecentRequest,
24579 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24580 assertTrue(GrouperClientWs.mostRecentRequest,
24581 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24582 assertTrue(GrouperClientWs.mostRecentRequest,
24583 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24584 assertTrue(GrouperClientWs.mostRecentRequest,
24585 !GrouperClientWs.mostRecentRequest.contains("params"));
24586 assertTrue(GrouperClientWs.mostRecentRequest,
24587 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24588 assertTrue(GrouperClientWs.mostRecentRequest,
24589 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24590 assertTrue(GrouperClientWs.mostRecentRequest,
24591 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24592 assertTrue(GrouperClientWs.mostRecentRequest,
24593 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24594 assertTrue(GrouperClientWs.mostRecentRequest,
24595 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24596 assertTrue(GrouperClientWs.mostRecentRequest,
24597 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24598 assertTrue(GrouperClientWs.mostRecentRequest,
24599 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24600 assertTrue(GrouperClientWs.mostRecentRequest,
24601 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24602 assertTrue(GrouperClientWs.mostRecentRequest,
24603 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24604 assertTrue(GrouperClientWs.mostRecentRequest,
24605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24606 assertTrue(GrouperClientWs.mostRecentRequest,
24607 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24608 assertTrue(GrouperClientWs.mostRecentRequest,
24609 GrouperClientWs.mostRecentRequest.contains("theValue"));
24610 assertTrue(GrouperClientWs.mostRecentRequest,
24611 GrouperClientWs.mostRecentRequest.contains("abc"));
24612 assertTrue(GrouperClientWs.mostRecentRequest,
24613 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24614 assertTrue(GrouperClientWs.mostRecentRequest,
24615 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24616 assertTrue(GrouperClientWs.mostRecentRequest,
24617 GrouperClientWs.mostRecentRequest.contains("limit"));
24618 assertTrue(GrouperClientWs.mostRecentRequest,
24619 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24620 assertTrue(GrouperClientWs.mostRecentRequest,
24621 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24622 assertTrue(GrouperClientWs.mostRecentRequest,
24623 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24624 assertTrue(GrouperClientWs.mostRecentRequest,
24625 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24626 assertTrue(GrouperClientWs.mostRecentRequest,
24627 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24628 assertTrue(GrouperClientWs.mostRecentRequest,
24629 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24630
24631
24632
24633
24634 baos = new ByteArrayOutputStream();
24635 System.setOut(new PrintStream(baos));
24636
24637 GrouperClient.main(GrouperClientUtils.splitTrim(
24638 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId(),
24639 " "));
24640
24641 System.out.flush();
24642 output = new String(baos.toByteArray());
24643
24644 System.setOut(systemOut);
24645
24646 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24647
24648
24649
24650 pattern = Pattern
24651 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24652
24653 assertEquals(1, GrouperUtil.length(outputLines));
24654 outputLine = outputLines[0];
24655
24656 matcher = pattern.matcher(outputLines[0]);
24657
24658 assertTrue(outputLine, matcher.matches());
24659 assertEquals(outputLine, "0", matcher.group(1));
24660 assertEquals(outputLine, "stem_asgn", matcher.group(2));
24661 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
24662 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
24663 assertEquals(outputLine, "assign", matcher.group(5));
24664 assertEquals(outputLine, "123", matcher.group(6));
24665 assertEquals(outputLine, "T", matcher.group(7));
24666 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
24667
24668 assertTrue(GrouperClientWs.mostRecentRequest,
24669 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24670 assertTrue(GrouperClientWs.mostRecentRequest,
24671 !GrouperClientWs.mostRecentRequest.contains("actions"));
24672 assertTrue(GrouperClientWs.mostRecentRequest,
24673 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24674 assertTrue(GrouperClientWs.mostRecentRequest,
24675 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24676 assertTrue(GrouperClientWs.mostRecentRequest,
24677 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24678 assertTrue(GrouperClientWs.mostRecentRequest,
24679 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24680 assertTrue(GrouperClientWs.mostRecentRequest,
24681 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24682 assertTrue(GrouperClientWs.mostRecentRequest,
24683 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24684 assertTrue(GrouperClientWs.mostRecentRequest,
24685 !GrouperClientWs.mostRecentRequest.contains("params"));
24686 assertTrue(GrouperClientWs.mostRecentRequest,
24687 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24688 assertTrue(GrouperClientWs.mostRecentRequest,
24689 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24690 assertTrue(GrouperClientWs.mostRecentRequest,
24691 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24692 assertTrue(GrouperClientWs.mostRecentRequest,
24693 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24694 assertTrue(GrouperClientWs.mostRecentRequest,
24695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24696 assertTrue(GrouperClientWs.mostRecentRequest,
24697 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24698 assertTrue(GrouperClientWs.mostRecentRequest,
24699 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24700 assertTrue(GrouperClientWs.mostRecentRequest,
24701 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24702 assertTrue(GrouperClientWs.mostRecentRequest,
24703 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24704 assertTrue(GrouperClientWs.mostRecentRequest,
24705 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24706 assertFalse(GrouperClientWs.mostRecentRequest,
24707 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24708 assertFalse(GrouperClientWs.mostRecentRequest,
24709 GrouperClientWs.mostRecentRequest.contains("theValue"));
24710 assertFalse(GrouperClientWs.mostRecentRequest,
24711 GrouperClientWs.mostRecentRequest.contains(">abc<"));
24712 assertTrue(GrouperClientWs.mostRecentRequest,
24713 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24714 assertFalse(GrouperClientWs.mostRecentRequest,
24715 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24716 assertTrue(GrouperClientWs.mostRecentRequest,
24717 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24718 assertTrue(GrouperClientWs.mostRecentRequest,
24719 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24720 assertTrue(GrouperClientWs.mostRecentRequest,
24721 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24722 assertTrue(GrouperClientWs.mostRecentRequest,
24723 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24724 assertTrue(GrouperClientWs.mostRecentRequest,
24725 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24726 assertTrue(GrouperClientWs.mostRecentRequest,
24727 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24728
24729
24730
24731
24732 baos = new ByteArrayOutputStream();
24733 System.setOut(new PrintStream(baos));
24734
24735 try {
24736 GrouperClient.main(GrouperClientUtils.splitTrim(
24737 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
24738 " "));
24739
24740 System.out.flush();
24741 output = new String(baos.toByteArray());
24742
24743 System.setOut(systemOut);
24744
24745 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24746
24747
24748
24749 pattern = Pattern
24750 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24751
24752 assertEquals(0, GrouperUtil.length(outputLines));
24753 fail("Why did it not fail?");
24754 } catch (Exception e) {
24755
24756 }
24757 assertTrue(GrouperClientWs.mostRecentRequest,
24758 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24759 assertTrue(GrouperClientWs.mostRecentRequest,
24760 !GrouperClientWs.mostRecentRequest.contains("actions"));
24761 assertTrue(GrouperClientWs.mostRecentRequest,
24762 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24763 assertTrue(GrouperClientWs.mostRecentRequest,
24764 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24765 assertTrue(GrouperClientWs.mostRecentRequest,
24766 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24767 assertTrue(GrouperClientWs.mostRecentRequest,
24768 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24769 assertTrue(GrouperClientWs.mostRecentRequest,
24770 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24771 assertTrue(GrouperClientWs.mostRecentRequest,
24772 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24773 assertTrue(GrouperClientWs.mostRecentRequest,
24774 !GrouperClientWs.mostRecentRequest.contains("params"));
24775 assertTrue(GrouperClientWs.mostRecentRequest,
24776 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24777 assertTrue(GrouperClientWs.mostRecentRequest,
24778 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24779 assertTrue(GrouperClientWs.mostRecentRequest,
24780 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24781 assertTrue(GrouperClientWs.mostRecentRequest,
24782 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24783 assertTrue(GrouperClientWs.mostRecentRequest,
24784 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24785 assertTrue(GrouperClientWs.mostRecentRequest,
24786 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24787 assertTrue(GrouperClientWs.mostRecentRequest,
24788 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24789 assertTrue(GrouperClientWs.mostRecentRequest,
24790 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24791 assertTrue(GrouperClientWs.mostRecentRequest,
24792 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24793 assertTrue(GrouperClientWs.mostRecentRequest,
24794 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24795 assertFalse(GrouperClientWs.mostRecentRequest,
24796 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24797 assertFalse(GrouperClientWs.mostRecentRequest,
24798 GrouperClientWs.mostRecentRequest.contains("theValue"));
24799 assertFalse(GrouperClientWs.mostRecentRequest,
24800 GrouperClientWs.mostRecentRequest.contains("abc"));
24801 assertTrue(GrouperClientWs.mostRecentRequest,
24802 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24803 assertFalse(GrouperClientWs.mostRecentRequest,
24804 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24805 assertTrue(GrouperClientWs.mostRecentRequest,
24806 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24807 assertTrue(GrouperClientWs.mostRecentRequest,
24808 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24809 assertTrue(GrouperClientWs.mostRecentRequest,
24810 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24811 assertTrue(GrouperClientWs.mostRecentRequest,
24812 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24813 assertTrue(GrouperClientWs.mostRecentRequest,
24814 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24815 assertTrue(GrouperClientWs.mostRecentRequest,
24816 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24817
24818
24819
24820
24821
24822 baos = new ByteArrayOutputStream();
24823 System.setOut(new PrintStream(baos));
24824
24825 GrouperClient.main(GrouperClientUtils.splitTrim(
24826 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId()
24827 + " --attributeDefValueType=integer --value=123 ",
24828 " "));
24829
24830 System.out.flush();
24831 output = new String(baos.toByteArray());
24832
24833 System.setOut(systemOut);
24834
24835 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24836
24837
24838
24839 pattern = Pattern
24840 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24841
24842 assertEquals(1, GrouperUtil.length(outputLines));
24843 outputLine = outputLines[0];
24844
24845 matcher = pattern.matcher(outputLines[0]);
24846
24847 assertTrue(outputLine, matcher.matches());
24848 assertEquals(outputLine, "0", matcher.group(1));
24849 assertEquals(outputLine, "stem_asgn", matcher.group(2));
24850 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
24851 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
24852 assertEquals(outputLine, "assign", matcher.group(5));
24853 assertEquals(outputLine, "123", matcher.group(6));
24854 assertEquals(outputLine, "T", matcher.group(7));
24855 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
24856
24857 assertTrue(GrouperClientWs.mostRecentRequest,
24858 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24859 assertTrue(GrouperClientWs.mostRecentRequest,
24860 !GrouperClientWs.mostRecentRequest.contains("actions"));
24861 assertTrue(GrouperClientWs.mostRecentRequest,
24862 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24863 assertTrue(GrouperClientWs.mostRecentRequest,
24864 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24865 assertTrue(GrouperClientWs.mostRecentRequest,
24866 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24867 assertTrue(GrouperClientWs.mostRecentRequest,
24868 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24869 assertTrue(GrouperClientWs.mostRecentRequest,
24870 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24871 assertTrue(GrouperClientWs.mostRecentRequest,
24872 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24873 assertTrue(GrouperClientWs.mostRecentRequest,
24874 !GrouperClientWs.mostRecentRequest.contains("params"));
24875 assertTrue(GrouperClientWs.mostRecentRequest,
24876 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24877 assertTrue(GrouperClientWs.mostRecentRequest,
24878 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24879 assertTrue(GrouperClientWs.mostRecentRequest,
24880 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24881 assertTrue(GrouperClientWs.mostRecentRequest,
24882 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24883 assertTrue(GrouperClientWs.mostRecentRequest,
24884 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24885 assertTrue(GrouperClientWs.mostRecentRequest,
24886 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24887 assertTrue(GrouperClientWs.mostRecentRequest,
24888 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24889 assertTrue(GrouperClientWs.mostRecentRequest,
24890 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24891 assertTrue(GrouperClientWs.mostRecentRequest,
24892 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24893 assertTrue(GrouperClientWs.mostRecentRequest,
24894 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24895 assertTrue(GrouperClientWs.mostRecentRequest,
24896 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24897 assertTrue(GrouperClientWs.mostRecentRequest,
24898 GrouperClientWs.mostRecentRequest.contains("theValue"));
24899 assertTrue(GrouperClientWs.mostRecentRequest,
24900 GrouperClientWs.mostRecentRequest.contains(">123<"));
24901 assertTrue(GrouperClientWs.mostRecentRequest,
24902 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24903 assertFalse(GrouperClientWs.mostRecentRequest,
24904 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24905 assertTrue(GrouperClientWs.mostRecentRequest,
24906 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24907 assertTrue(GrouperClientWs.mostRecentRequest,
24908 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24909 assertTrue(GrouperClientWs.mostRecentRequest,
24910 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24911 assertTrue(GrouperClientWs.mostRecentRequest,
24912 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24913 assertTrue(GrouperClientWs.mostRecentRequest,
24914 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24915 assertTrue(GrouperClientWs.mostRecentRequest,
24916 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24917
24918
24919
24920
24921
24922 baos = new ByteArrayOutputStream();
24923 System.setOut(new PrintStream(baos));
24924
24925 GrouperClient.main(GrouperClientUtils.splitTrim(
24926 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId()
24927 + " --attributeDefValueType=integer --value=1234 ",
24928 " "));
24929
24930 System.out.flush();
24931 output = new String(baos.toByteArray());
24932
24933 System.setOut(systemOut);
24934
24935 outputLines = GrouperClientUtils.splitTrim(output, "\n");
24936
24937
24938
24939 pattern = Pattern
24940 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24941
24942 assertEquals(0, GrouperUtil.length(outputLines));
24943
24944 assertTrue(GrouperClientWs.mostRecentRequest,
24945 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24946 assertTrue(GrouperClientWs.mostRecentRequest,
24947 !GrouperClientWs.mostRecentRequest.contains("actions"));
24948 assertTrue(GrouperClientWs.mostRecentRequest,
24949 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24950 assertTrue(GrouperClientWs.mostRecentRequest,
24951 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24952 assertTrue(GrouperClientWs.mostRecentRequest,
24953 !GrouperClientWs.mostRecentRequest.contains("enabled"));
24954 assertTrue(GrouperClientWs.mostRecentRequest,
24955 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24956 assertTrue(GrouperClientWs.mostRecentRequest,
24957 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24958 assertTrue(GrouperClientWs.mostRecentRequest,
24959 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24960 assertTrue(GrouperClientWs.mostRecentRequest,
24961 !GrouperClientWs.mostRecentRequest.contains("params"));
24962 assertTrue(GrouperClientWs.mostRecentRequest,
24963 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24964 assertTrue(GrouperClientWs.mostRecentRequest,
24965 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24966 assertTrue(GrouperClientWs.mostRecentRequest,
24967 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24968 assertTrue(GrouperClientWs.mostRecentRequest,
24969 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24970 assertTrue(GrouperClientWs.mostRecentRequest,
24971 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24972 assertTrue(GrouperClientWs.mostRecentRequest,
24973 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24974 assertTrue(GrouperClientWs.mostRecentRequest,
24975 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24976 assertTrue(GrouperClientWs.mostRecentRequest,
24977 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24978 assertTrue(GrouperClientWs.mostRecentRequest,
24979 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24980 assertTrue(GrouperClientWs.mostRecentRequest,
24981 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24982 assertTrue(GrouperClientWs.mostRecentRequest,
24983 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24984 assertTrue(GrouperClientWs.mostRecentRequest,
24985 GrouperClientWs.mostRecentRequest.contains("theValue"));
24986 assertTrue(GrouperClientWs.mostRecentRequest,
24987 GrouperClientWs.mostRecentRequest.contains("1234"));
24988 assertTrue(GrouperClientWs.mostRecentRequest,
24989 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24990 assertFalse(GrouperClientWs.mostRecentRequest,
24991 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24992 assertTrue(GrouperClientWs.mostRecentRequest,
24993 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24994 assertTrue(GrouperClientWs.mostRecentRequest,
24995 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24996 assertTrue(GrouperClientWs.mostRecentRequest,
24997 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24998 assertTrue(GrouperClientWs.mostRecentRequest,
24999 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25000 assertTrue(GrouperClientWs.mostRecentRequest,
25001 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25002 assertTrue(GrouperClientWs.mostRecentRequest,
25003 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25004
25005
25006
25007
25008
25009 baos = new ByteArrayOutputStream();
25010 System.setOut(new PrintStream(baos));
25011
25012 GrouperClient.main(GrouperClientUtils.splitTrim(
25013 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId()
25014 + " --includeAssignmentsFromAssignments=T ",
25015 " "));
25016
25017 System.out.flush();
25018 output = new String(baos.toByteArray());
25019
25020 System.setOut(systemOut);
25021
25022 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25023
25024
25025
25026 pattern = Pattern
25027 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25028
25029 assertEquals(2, GrouperUtil.length(outputLines));
25030 outputLine = outputLines[0];
25031
25032 matcher = pattern.matcher(outputLine);
25033
25034 assertTrue(outputLine, matcher.matches());
25035 assertEquals(outputLine, "0", matcher.group(1));
25036 assertEquals(outputLine, "stem", matcher.group(2));
25037 assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
25038 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
25039 assertEquals(outputLine, "assign", matcher.group(5));
25040 assertEquals(outputLine, "abc", matcher.group(6));
25041 assertEquals(outputLine, "T", matcher.group(7));
25042 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
25043
25044 outputLine = outputLines[1];
25045
25046 matcher = pattern.matcher(outputLine);
25047
25048 assertTrue(outputLine, matcher.matches());
25049 assertEquals(outputLine, "1", matcher.group(1));
25050 assertEquals(outputLine, "stem_asgn", matcher.group(2));
25051 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25052 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25053 assertEquals(outputLine, "assign", matcher.group(5));
25054 assertEquals(outputLine, "123", matcher.group(6));
25055 assertEquals(outputLine, "T", matcher.group(7));
25056 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25057
25058 assertTrue(GrouperClientWs.mostRecentRequest,
25059 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25060 assertTrue(GrouperClientWs.mostRecentRequest,
25061 !GrouperClientWs.mostRecentRequest.contains("actions"));
25062 assertTrue(GrouperClientWs.mostRecentRequest,
25063 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25064 assertTrue(GrouperClientWs.mostRecentRequest,
25065 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25066 assertTrue(GrouperClientWs.mostRecentRequest,
25067 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25068 assertTrue(GrouperClientWs.mostRecentRequest,
25069 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25070 assertTrue(GrouperClientWs.mostRecentRequest,
25071 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25072 assertTrue(GrouperClientWs.mostRecentRequest,
25073 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25074 assertTrue(GrouperClientWs.mostRecentRequest,
25075 !GrouperClientWs.mostRecentRequest.contains("params"));
25076 assertTrue(GrouperClientWs.mostRecentRequest,
25077 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25078 assertTrue(GrouperClientWs.mostRecentRequest,
25079 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25080 assertTrue(GrouperClientWs.mostRecentRequest,
25081 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25082 assertTrue(GrouperClientWs.mostRecentRequest,
25083 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25084 assertTrue(GrouperClientWs.mostRecentRequest,
25085 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25086 assertTrue(GrouperClientWs.mostRecentRequest,
25087 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25088 assertTrue(GrouperClientWs.mostRecentRequest,
25089 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25090 assertTrue(GrouperClientWs.mostRecentRequest,
25091 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25092 assertTrue(GrouperClientWs.mostRecentRequest,
25093 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25094 assertTrue(GrouperClientWs.mostRecentRequest,
25095 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25096 assertFalse(GrouperClientWs.mostRecentRequest,
25097 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25098 assertFalse(GrouperClientWs.mostRecentRequest,
25099 GrouperClientWs.mostRecentRequest.contains("theValue"));
25100 assertFalse(GrouperClientWs.mostRecentRequest,
25101 GrouperClientWs.mostRecentRequest.contains(">123<"));
25102 assertTrue(GrouperClientWs.mostRecentRequest,
25103 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25104 assertFalse(GrouperClientWs.mostRecentRequest,
25105 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25106 assertTrue(GrouperClientWs.mostRecentRequest,
25107 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25108 assertTrue(GrouperClientWs.mostRecentRequest,
25109 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25110 assertTrue(GrouperClientWs.mostRecentRequest,
25111 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25112 assertTrue(GrouperClientWs.mostRecentRequest,
25113 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25114 assertTrue(GrouperClientWs.mostRecentRequest,
25115 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25116 assertTrue(GrouperClientWs.mostRecentRequest,
25117 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25118
25119
25120
25121
25122
25123 baos = new ByteArrayOutputStream();
25124 System.setOut(new PrintStream(baos));
25125
25126 try {
25127 GrouperClient.main(GrouperClientUtils.splitTrim(
25128 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
25129 ,
25130 " "));
25131
25132 System.out.flush();
25133 output = new String(baos.toByteArray());
25134
25135 System.setOut(systemOut);
25136
25137 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25138
25139
25140
25141 pattern = Pattern
25142 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25143
25144 assertEquals(0, GrouperUtil.length(outputLines));
25145 fail("Shouldnt get here");
25146 } catch (Exception e) {
25147
25148 } finally {
25149 System.setOut(systemOut);
25150
25151 }
25152
25153 assertTrue(GrouperClientWs.mostRecentRequest,
25154 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25155 assertTrue(GrouperClientWs.mostRecentRequest,
25156 !GrouperClientWs.mostRecentRequest.contains("actions"));
25157 assertTrue(GrouperClientWs.mostRecentRequest,
25158 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25159 assertTrue(GrouperClientWs.mostRecentRequest,
25160 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25161 assertTrue(GrouperClientWs.mostRecentRequest,
25162 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25163 assertTrue(GrouperClientWs.mostRecentRequest,
25164 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25165 assertTrue(GrouperClientWs.mostRecentRequest,
25166 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25167 assertTrue(GrouperClientWs.mostRecentRequest,
25168 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25169 assertTrue(GrouperClientWs.mostRecentRequest,
25170 !GrouperClientWs.mostRecentRequest.contains("params"));
25171 assertTrue(GrouperClientWs.mostRecentRequest,
25172 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25173 assertTrue(GrouperClientWs.mostRecentRequest,
25174 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25175 assertFalse(GrouperClientWs.mostRecentRequest,
25176 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25177 assertTrue(GrouperClientWs.mostRecentRequest,
25178 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25179 assertTrue(GrouperClientWs.mostRecentRequest,
25180 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25181 assertTrue(GrouperClientWs.mostRecentRequest,
25182 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25183 assertTrue(GrouperClientWs.mostRecentRequest,
25184 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25185 assertTrue(GrouperClientWs.mostRecentRequest,
25186 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25187 assertTrue(GrouperClientWs.mostRecentRequest,
25188 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25189 assertTrue(GrouperClientWs.mostRecentRequest,
25190 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25191 assertTrue(GrouperClientWs.mostRecentRequest,
25192 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25193 assertFalse(GrouperClientWs.mostRecentRequest,
25194 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25195 assertFalse(GrouperClientWs.mostRecentRequest,
25196 GrouperClientWs.mostRecentRequest.contains("theValue"));
25197 assertFalse(GrouperClientWs.mostRecentRequest,
25198 GrouperClientWs.mostRecentRequest.contains(">123<"));
25199 assertFalse(GrouperClientWs.mostRecentRequest,
25200 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25201 assertFalse(GrouperClientWs.mostRecentRequest,
25202 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25203 assertTrue(GrouperClientWs.mostRecentRequest,
25204 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25205 assertTrue(GrouperClientWs.mostRecentRequest,
25206 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25207 assertTrue(GrouperClientWs.mostRecentRequest,
25208 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25209 assertTrue(GrouperClientWs.mostRecentRequest,
25210 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25211 assertTrue(GrouperClientWs.mostRecentRequest,
25212 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25213 assertTrue(GrouperClientWs.mostRecentRequest,
25214 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25215
25216
25217
25218
25219 baos = new ByteArrayOutputStream();
25220 System.setOut(new PrintStream(baos));
25221
25222 GrouperClient.main(GrouperClientUtils.splitTrim(
25223 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
25224 ,
25225 " "));
25226
25227 System.out.flush();
25228 output = new String(baos.toByteArray());
25229
25230 System.setOut(systemOut);
25231
25232 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25233
25234
25235
25236 pattern = Pattern
25237 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25238
25239 assertEquals(1, GrouperUtil.length(outputLines));
25240
25241 outputLine = outputLines[0];
25242
25243 matcher = pattern.matcher(outputLine);
25244
25245 assertTrue(outputLine, matcher.matches());
25246 assertEquals(outputLine, "0", matcher.group(1));
25247 assertEquals(outputLine, "stem_asgn", matcher.group(2));
25248 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25249 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25250 assertEquals(outputLine, "assign", matcher.group(5));
25251 assertEquals(outputLine, "123", matcher.group(6));
25252 assertEquals(outputLine, "T", matcher.group(7));
25253 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25254
25255 assertTrue(GrouperClientWs.mostRecentRequest,
25256 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25257 assertTrue(GrouperClientWs.mostRecentRequest,
25258 !GrouperClientWs.mostRecentRequest.contains("actions"));
25259 assertTrue(GrouperClientWs.mostRecentRequest,
25260 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25261 assertTrue(GrouperClientWs.mostRecentRequest,
25262 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25263 assertTrue(GrouperClientWs.mostRecentRequest,
25264 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25265 assertTrue(GrouperClientWs.mostRecentRequest,
25266 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25267 assertTrue(GrouperClientWs.mostRecentRequest,
25268 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25269 assertTrue(GrouperClientWs.mostRecentRequest,
25270 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25271 assertTrue(GrouperClientWs.mostRecentRequest,
25272 !GrouperClientWs.mostRecentRequest.contains("params"));
25273 assertTrue(GrouperClientWs.mostRecentRequest,
25274 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25275 assertTrue(GrouperClientWs.mostRecentRequest,
25276 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25277 assertFalse(GrouperClientWs.mostRecentRequest,
25278 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25279 assertTrue(GrouperClientWs.mostRecentRequest,
25280 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25281 assertTrue(GrouperClientWs.mostRecentRequest,
25282 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25283 assertTrue(GrouperClientWs.mostRecentRequest,
25284 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25285 assertTrue(GrouperClientWs.mostRecentRequest,
25286 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25287 assertTrue(GrouperClientWs.mostRecentRequest,
25288 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25289 assertTrue(GrouperClientWs.mostRecentRequest,
25290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25291 assertTrue(GrouperClientWs.mostRecentRequest,
25292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25293 assertTrue(GrouperClientWs.mostRecentRequest,
25294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25295 assertFalse(GrouperClientWs.mostRecentRequest,
25296 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25297 assertFalse(GrouperClientWs.mostRecentRequest,
25298 GrouperClientWs.mostRecentRequest.contains("theValue"));
25299 assertFalse(GrouperClientWs.mostRecentRequest,
25300 GrouperClientWs.mostRecentRequest.contains(">123<"));
25301 assertFalse(GrouperClientWs.mostRecentRequest,
25302 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25303 assertFalse(GrouperClientWs.mostRecentRequest,
25304 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25305 assertTrue(GrouperClientWs.mostRecentRequest,
25306 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25307 assertTrue(GrouperClientWs.mostRecentRequest,
25308 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25309 assertTrue(GrouperClientWs.mostRecentRequest,
25310 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25311 assertTrue(GrouperClientWs.mostRecentRequest,
25312 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25313 assertTrue(GrouperClientWs.mostRecentRequest,
25314 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25315 assertTrue(GrouperClientWs.mostRecentRequest,
25316 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25317
25318
25319
25320
25321
25322 baos = new ByteArrayOutputStream();
25323 System.setOut(new PrintStream(baos));
25324
25325 GrouperClient.main(GrouperClientUtils.splitTrim(
25326 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
25327 ,
25328 " "));
25329
25330 System.out.flush();
25331 output = new String(baos.toByteArray());
25332
25333 System.setOut(systemOut);
25334
25335 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25336
25337
25338
25339 pattern = Pattern
25340 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25341
25342 assertEquals(1, GrouperUtil.length(outputLines));
25343
25344 outputLine = outputLines[0];
25345
25346 matcher = pattern.matcher(outputLine);
25347
25348 assertTrue(outputLine, matcher.matches());
25349 assertEquals(outputLine, "0", matcher.group(1));
25350 assertEquals(outputLine, "stem_asgn", matcher.group(2));
25351 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25352 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25353 assertEquals(outputLine, "assign", matcher.group(5));
25354 assertEquals(outputLine, "123", matcher.group(6));
25355 assertEquals(outputLine, "T", matcher.group(7));
25356 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25357
25358 assertTrue(GrouperClientWs.mostRecentRequest,
25359 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25360 assertTrue(GrouperClientWs.mostRecentRequest,
25361 !GrouperClientWs.mostRecentRequest.contains("actions"));
25362 assertTrue(GrouperClientWs.mostRecentRequest,
25363 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25364 assertTrue(GrouperClientWs.mostRecentRequest,
25365 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25366 assertTrue(GrouperClientWs.mostRecentRequest,
25367 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25368 assertTrue(GrouperClientWs.mostRecentRequest,
25369 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25370 assertTrue(GrouperClientWs.mostRecentRequest,
25371 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25372 assertTrue(GrouperClientWs.mostRecentRequest,
25373 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25374 assertTrue(GrouperClientWs.mostRecentRequest,
25375 !GrouperClientWs.mostRecentRequest.contains("params"));
25376 assertTrue(GrouperClientWs.mostRecentRequest,
25377 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25378 assertTrue(GrouperClientWs.mostRecentRequest,
25379 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25380 assertFalse(GrouperClientWs.mostRecentRequest,
25381 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25382 assertFalse(GrouperClientWs.mostRecentRequest,
25383 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25384 assertTrue(GrouperClientWs.mostRecentRequest,
25385 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25386 assertTrue(GrouperClientWs.mostRecentRequest,
25387 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25388 assertTrue(GrouperClientWs.mostRecentRequest,
25389 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25390 assertTrue(GrouperClientWs.mostRecentRequest,
25391 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25392 assertTrue(GrouperClientWs.mostRecentRequest,
25393 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25394 assertTrue(GrouperClientWs.mostRecentRequest,
25395 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25396 assertTrue(GrouperClientWs.mostRecentRequest,
25397 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25398 assertFalse(GrouperClientWs.mostRecentRequest,
25399 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25400 assertFalse(GrouperClientWs.mostRecentRequest,
25401 GrouperClientWs.mostRecentRequest.contains("theValue"));
25402 assertFalse(GrouperClientWs.mostRecentRequest,
25403 GrouperClientWs.mostRecentRequest.contains(">123<"));
25404 assertFalse(GrouperClientWs.mostRecentRequest,
25405 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25406 assertFalse(GrouperClientWs.mostRecentRequest,
25407 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25408 assertTrue(GrouperClientWs.mostRecentRequest,
25409 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25410 assertTrue(GrouperClientWs.mostRecentRequest,
25411 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25412 assertTrue(GrouperClientWs.mostRecentRequest,
25413 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25414 assertTrue(GrouperClientWs.mostRecentRequest,
25415 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25416 assertTrue(GrouperClientWs.mostRecentRequest,
25417 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25418 assertTrue(GrouperClientWs.mostRecentRequest,
25419 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25420
25421
25422
25423
25424
25425
25426 baos = new ByteArrayOutputStream();
25427 System.setOut(new PrintStream(baos));
25428
25429 try {
25430 GrouperClient.main(GrouperClientUtils.splitTrim(
25431 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
25432 ,
25433 " "));
25434
25435 System.out.flush();
25436 output = new String(baos.toByteArray());
25437
25438 System.setOut(systemOut);
25439
25440 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25441
25442
25443
25444 pattern = Pattern
25445 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25446
25447 assertEquals(0, GrouperUtil.length(outputLines));
25448
25449 fail("shouldnt get here");
25450 } catch (Exception e) {
25451
25452 } finally {
25453 System.setOut(systemOut);
25454 }
25455
25456 assertTrue(GrouperClientWs.mostRecentRequest,
25457 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25458 assertTrue(GrouperClientWs.mostRecentRequest,
25459 !GrouperClientWs.mostRecentRequest.contains("actions"));
25460 assertTrue(GrouperClientWs.mostRecentRequest,
25461 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25462 assertTrue(GrouperClientWs.mostRecentRequest,
25463 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25464 assertTrue(GrouperClientWs.mostRecentRequest,
25465 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25466 assertTrue(GrouperClientWs.mostRecentRequest,
25467 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25468 assertTrue(GrouperClientWs.mostRecentRequest,
25469 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25470 assertTrue(GrouperClientWs.mostRecentRequest,
25471 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25472 assertTrue(GrouperClientWs.mostRecentRequest,
25473 !GrouperClientWs.mostRecentRequest.contains("params"));
25474 assertTrue(GrouperClientWs.mostRecentRequest,
25475 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25476 assertTrue(GrouperClientWs.mostRecentRequest,
25477 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25478 assertFalse(GrouperClientWs.mostRecentRequest,
25479 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25480 assertFalse(GrouperClientWs.mostRecentRequest,
25481 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25482 assertTrue(GrouperClientWs.mostRecentRequest,
25483 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25484 assertTrue(GrouperClientWs.mostRecentRequest,
25485 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25486 assertTrue(GrouperClientWs.mostRecentRequest,
25487 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25488 assertTrue(GrouperClientWs.mostRecentRequest,
25489 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25490 assertTrue(GrouperClientWs.mostRecentRequest,
25491 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25492 assertTrue(GrouperClientWs.mostRecentRequest,
25493 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25494 assertTrue(GrouperClientWs.mostRecentRequest,
25495 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25496 assertFalse(GrouperClientWs.mostRecentRequest,
25497 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25498 assertFalse(GrouperClientWs.mostRecentRequest,
25499 GrouperClientWs.mostRecentRequest.contains("theValue"));
25500 assertFalse(GrouperClientWs.mostRecentRequest,
25501 GrouperClientWs.mostRecentRequest.contains(">123<"));
25502 assertFalse(GrouperClientWs.mostRecentRequest,
25503 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25504 assertFalse(GrouperClientWs.mostRecentRequest,
25505 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25506 assertTrue(GrouperClientWs.mostRecentRequest,
25507 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25508 assertTrue(GrouperClientWs.mostRecentRequest,
25509 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25510 assertTrue(GrouperClientWs.mostRecentRequest,
25511 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25512 assertTrue(GrouperClientWs.mostRecentRequest,
25513 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25514 assertTrue(GrouperClientWs.mostRecentRequest,
25515 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25516 assertTrue(GrouperClientWs.mostRecentRequest,
25517 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25518
25519
25520
25521
25522
25523 baos = new ByteArrayOutputStream();
25524 System.setOut(new PrintStream(baos));
25525
25526 GrouperClient.main(GrouperClientUtils.splitTrim(
25527 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
25528 ,
25529 " "));
25530
25531 System.out.flush();
25532 output = new String(baos.toByteArray());
25533
25534 System.setOut(systemOut);
25535
25536 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25537
25538
25539
25540 pattern = Pattern
25541 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25542
25543 assertEquals(1, GrouperUtil.length(outputLines));
25544
25545 outputLine = outputLines[0];
25546
25547 matcher = pattern.matcher(outputLine);
25548
25549 assertTrue(outputLine, matcher.matches());
25550 assertEquals(outputLine, "0", matcher.group(1));
25551 assertEquals(outputLine, "stem_asgn", matcher.group(2));
25552 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25553 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25554 assertEquals(outputLine, "assign", matcher.group(5));
25555 assertEquals(outputLine, "123", matcher.group(6));
25556 assertEquals(outputLine, "T", matcher.group(7));
25557 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25558
25559 assertTrue(GrouperClientWs.mostRecentRequest,
25560 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25561 assertTrue(GrouperClientWs.mostRecentRequest,
25562 !GrouperClientWs.mostRecentRequest.contains("actions"));
25563 assertTrue(GrouperClientWs.mostRecentRequest,
25564 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25565 assertTrue(GrouperClientWs.mostRecentRequest,
25566 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25567 assertTrue(GrouperClientWs.mostRecentRequest,
25568 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25569 assertTrue(GrouperClientWs.mostRecentRequest,
25570 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25571 assertTrue(GrouperClientWs.mostRecentRequest,
25572 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25573 assertTrue(GrouperClientWs.mostRecentRequest,
25574 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25575 assertTrue(GrouperClientWs.mostRecentRequest,
25576 !GrouperClientWs.mostRecentRequest.contains("params"));
25577 assertTrue(GrouperClientWs.mostRecentRequest,
25578 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25579 assertTrue(GrouperClientWs.mostRecentRequest,
25580 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25581 assertFalse(GrouperClientWs.mostRecentRequest,
25582 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25583 assertTrue(GrouperClientWs.mostRecentRequest,
25584 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25585 assertTrue(GrouperClientWs.mostRecentRequest,
25586 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25587 assertTrue(GrouperClientWs.mostRecentRequest,
25588 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25589 assertTrue(GrouperClientWs.mostRecentRequest,
25590 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25591 assertTrue(GrouperClientWs.mostRecentRequest,
25592 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25593 assertTrue(GrouperClientWs.mostRecentRequest,
25594 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25595 assertTrue(GrouperClientWs.mostRecentRequest,
25596 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25597 assertTrue(GrouperClientWs.mostRecentRequest,
25598 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25599 assertFalse(GrouperClientWs.mostRecentRequest,
25600 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25601 assertFalse(GrouperClientWs.mostRecentRequest,
25602 GrouperClientWs.mostRecentRequest.contains("theValue"));
25603 assertFalse(GrouperClientWs.mostRecentRequest,
25604 GrouperClientWs.mostRecentRequest.contains(">123<"));
25605 assertFalse(GrouperClientWs.mostRecentRequest,
25606 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25607 assertFalse(GrouperClientWs.mostRecentRequest,
25608 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25609 assertTrue(GrouperClientWs.mostRecentRequest,
25610 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25611 assertTrue(GrouperClientWs.mostRecentRequest,
25612 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25613 assertTrue(GrouperClientWs.mostRecentRequest,
25614 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25615 assertTrue(GrouperClientWs.mostRecentRequest,
25616 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25617 assertTrue(GrouperClientWs.mostRecentRequest,
25618 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25619 assertTrue(GrouperClientWs.mostRecentRequest,
25620 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25621
25622
25623
25624
25625
25626 baos = new ByteArrayOutputStream();
25627 System.setOut(new PrintStream(baos));
25628
25629 GrouperClient.main(GrouperClientUtils.splitTrim(
25630 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
25631 ,
25632 " "));
25633
25634 System.out.flush();
25635 output = new String(baos.toByteArray());
25636
25637 System.setOut(systemOut);
25638
25639 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25640
25641
25642
25643 pattern = Pattern
25644 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25645
25646 assertEquals(1, GrouperUtil.length(outputLines));
25647
25648 outputLine = outputLines[0];
25649
25650 matcher = pattern.matcher(outputLine);
25651
25652 assertTrue(outputLine, matcher.matches());
25653 assertEquals(outputLine, "0", matcher.group(1));
25654 assertEquals(outputLine, "stem_asgn", matcher.group(2));
25655 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25656 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25657 assertEquals(outputLine, "assign", matcher.group(5));
25658 assertEquals(outputLine, "123", matcher.group(6));
25659 assertEquals(outputLine, "T", matcher.group(7));
25660 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25661
25662 assertTrue(GrouperClientWs.mostRecentRequest,
25663 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25664 assertTrue(GrouperClientWs.mostRecentRequest,
25665 !GrouperClientWs.mostRecentRequest.contains("actions"));
25666 assertTrue(GrouperClientWs.mostRecentRequest,
25667 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25668 assertTrue(GrouperClientWs.mostRecentRequest,
25669 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25670 assertTrue(GrouperClientWs.mostRecentRequest,
25671 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25672 assertTrue(GrouperClientWs.mostRecentRequest,
25673 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25674 assertTrue(GrouperClientWs.mostRecentRequest,
25675 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25676 assertTrue(GrouperClientWs.mostRecentRequest,
25677 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25678 assertTrue(GrouperClientWs.mostRecentRequest,
25679 !GrouperClientWs.mostRecentRequest.contains("params"));
25680 assertTrue(GrouperClientWs.mostRecentRequest,
25681 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25682 assertTrue(GrouperClientWs.mostRecentRequest,
25683 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25684 assertFalse(GrouperClientWs.mostRecentRequest,
25685 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25686 assertTrue(GrouperClientWs.mostRecentRequest,
25687 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25688 assertTrue(GrouperClientWs.mostRecentRequest,
25689 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25690 assertTrue(GrouperClientWs.mostRecentRequest,
25691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25692 assertTrue(GrouperClientWs.mostRecentRequest,
25693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25694 assertTrue(GrouperClientWs.mostRecentRequest,
25695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25696 assertTrue(GrouperClientWs.mostRecentRequest,
25697 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25698 assertTrue(GrouperClientWs.mostRecentRequest,
25699 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25700 assertTrue(GrouperClientWs.mostRecentRequest,
25701 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25702 assertFalse(GrouperClientWs.mostRecentRequest,
25703 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25704 assertFalse(GrouperClientWs.mostRecentRequest,
25705 GrouperClientWs.mostRecentRequest.contains("theValue"));
25706 assertFalse(GrouperClientWs.mostRecentRequest,
25707 GrouperClientWs.mostRecentRequest.contains(">123<"));
25708 assertFalse(GrouperClientWs.mostRecentRequest,
25709 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25710 assertFalse(GrouperClientWs.mostRecentRequest,
25711 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25712 assertTrue(GrouperClientWs.mostRecentRequest,
25713 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25714 assertTrue(GrouperClientWs.mostRecentRequest,
25715 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25716 assertTrue(GrouperClientWs.mostRecentRequest,
25717 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25718 assertTrue(GrouperClientWs.mostRecentRequest,
25719 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25720 assertTrue(GrouperClientWs.mostRecentRequest,
25721 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25722 assertTrue(GrouperClientWs.mostRecentRequest,
25723 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25724
25725
25726
25727
25728
25729
25730 baos = new ByteArrayOutputStream();
25731 System.setOut(new PrintStream(baos));
25732
25733 try {
25734 GrouperClient.main(GrouperClientUtils.splitTrim(
25735 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
25736 ,
25737 " "));
25738
25739 System.out.flush();
25740 output = new String(baos.toByteArray());
25741
25742 System.setOut(systemOut);
25743
25744 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25745
25746
25747
25748 pattern = Pattern
25749 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25750
25751 assertEquals(0, GrouperUtil.length(outputLines));
25752 fail("Shouldnt get here");
25753 } catch (Exception e) {
25754
25755 } finally {
25756
25757 System.setOut(systemOut);
25758
25759 }
25760
25761 assertTrue(GrouperClientWs.mostRecentRequest,
25762 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25763 assertTrue(GrouperClientWs.mostRecentRequest,
25764 !GrouperClientWs.mostRecentRequest.contains("actions"));
25765 assertTrue(GrouperClientWs.mostRecentRequest,
25766 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25767 assertTrue(GrouperClientWs.mostRecentRequest,
25768 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25769 assertTrue(GrouperClientWs.mostRecentRequest,
25770 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25771 assertTrue(GrouperClientWs.mostRecentRequest,
25772 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25773 assertTrue(GrouperClientWs.mostRecentRequest,
25774 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25775 assertTrue(GrouperClientWs.mostRecentRequest,
25776 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25777 assertTrue(GrouperClientWs.mostRecentRequest,
25778 !GrouperClientWs.mostRecentRequest.contains("params"));
25779 assertTrue(GrouperClientWs.mostRecentRequest,
25780 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25781 assertTrue(GrouperClientWs.mostRecentRequest,
25782 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25783 assertFalse(GrouperClientWs.mostRecentRequest,
25784 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25785 assertTrue(GrouperClientWs.mostRecentRequest,
25786 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25787 assertTrue(GrouperClientWs.mostRecentRequest,
25788 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25789 assertTrue(GrouperClientWs.mostRecentRequest,
25790 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25791 assertTrue(GrouperClientWs.mostRecentRequest,
25792 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25793 assertTrue(GrouperClientWs.mostRecentRequest,
25794 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25795 assertTrue(GrouperClientWs.mostRecentRequest,
25796 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25797 assertTrue(GrouperClientWs.mostRecentRequest,
25798 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25799 assertTrue(GrouperClientWs.mostRecentRequest,
25800 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25801 assertFalse(GrouperClientWs.mostRecentRequest,
25802 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25803 assertFalse(GrouperClientWs.mostRecentRequest,
25804 GrouperClientWs.mostRecentRequest.contains("theValue"));
25805 assertFalse(GrouperClientWs.mostRecentRequest,
25806 GrouperClientWs.mostRecentRequest.contains(">123<"));
25807 assertFalse(GrouperClientWs.mostRecentRequest,
25808 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25809 assertFalse(GrouperClientWs.mostRecentRequest,
25810 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25811 assertTrue(GrouperClientWs.mostRecentRequest,
25812 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25813 assertTrue(GrouperClientWs.mostRecentRequest,
25814 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25815 assertTrue(GrouperClientWs.mostRecentRequest,
25816 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25817 assertTrue(GrouperClientWs.mostRecentRequest,
25818 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25819 assertTrue(GrouperClientWs.mostRecentRequest,
25820 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25821 assertTrue(GrouperClientWs.mostRecentRequest,
25822 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25823
25824
25825
25826
25827
25828 baos = new ByteArrayOutputStream();
25829 System.setOut(new PrintStream(baos));
25830
25831 GrouperClient.main(GrouperClientUtils.splitTrim(
25832 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
25833 ,
25834 " "));
25835
25836 System.out.flush();
25837 output = new String(baos.toByteArray());
25838
25839 System.setOut(systemOut);
25840
25841 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25842
25843
25844
25845 pattern = Pattern
25846 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25847
25848 assertEquals(1, GrouperUtil.length(outputLines));
25849
25850 outputLine = outputLines[0];
25851
25852 matcher = pattern.matcher(outputLine);
25853
25854 assertTrue(outputLine, matcher.matches());
25855 assertEquals(outputLine, "0", matcher.group(1));
25856 assertEquals(outputLine, "stem_asgn", matcher.group(2));
25857 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25858 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25859 assertEquals(outputLine, "assign", matcher.group(5));
25860 assertEquals(outputLine, "123", matcher.group(6));
25861 assertEquals(outputLine, "T", matcher.group(7));
25862 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25863
25864 assertTrue(GrouperClientWs.mostRecentRequest,
25865 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25866 assertTrue(GrouperClientWs.mostRecentRequest,
25867 !GrouperClientWs.mostRecentRequest.contains("actions"));
25868 assertTrue(GrouperClientWs.mostRecentRequest,
25869 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25870 assertTrue(GrouperClientWs.mostRecentRequest,
25871 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25872 assertTrue(GrouperClientWs.mostRecentRequest,
25873 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25874 assertTrue(GrouperClientWs.mostRecentRequest,
25875 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25876 assertTrue(GrouperClientWs.mostRecentRequest,
25877 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25878 assertTrue(GrouperClientWs.mostRecentRequest,
25879 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25880 assertTrue(GrouperClientWs.mostRecentRequest,
25881 !GrouperClientWs.mostRecentRequest.contains("params"));
25882 assertTrue(GrouperClientWs.mostRecentRequest,
25883 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25884 assertTrue(GrouperClientWs.mostRecentRequest,
25885 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25886 assertFalse(GrouperClientWs.mostRecentRequest,
25887 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25888 assertFalse(GrouperClientWs.mostRecentRequest,
25889 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25890 assertTrue(GrouperClientWs.mostRecentRequest,
25891 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25892 assertTrue(GrouperClientWs.mostRecentRequest,
25893 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25894 assertTrue(GrouperClientWs.mostRecentRequest,
25895 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25896 assertTrue(GrouperClientWs.mostRecentRequest,
25897 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25898 assertTrue(GrouperClientWs.mostRecentRequest,
25899 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25900 assertTrue(GrouperClientWs.mostRecentRequest,
25901 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25902 assertTrue(GrouperClientWs.mostRecentRequest,
25903 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25904 assertFalse(GrouperClientWs.mostRecentRequest,
25905 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25906 assertFalse(GrouperClientWs.mostRecentRequest,
25907 GrouperClientWs.mostRecentRequest.contains("theValue"));
25908 assertFalse(GrouperClientWs.mostRecentRequest,
25909 GrouperClientWs.mostRecentRequest.contains(">123<"));
25910 assertFalse(GrouperClientWs.mostRecentRequest,
25911 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25912 assertFalse(GrouperClientWs.mostRecentRequest,
25913 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25914 assertTrue(GrouperClientWs.mostRecentRequest,
25915 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25916 assertTrue(GrouperClientWs.mostRecentRequest,
25917 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25918 assertTrue(GrouperClientWs.mostRecentRequest,
25919 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25920 assertTrue(GrouperClientWs.mostRecentRequest,
25921 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25922
25923
25924
25925
25926
25927
25928 baos = new ByteArrayOutputStream();
25929 System.setOut(new PrintStream(baos));
25930
25931 try {
25932 GrouperClient.main(GrouperClientUtils.splitTrim(
25933 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
25934 ,
25935 " "));
25936
25937 System.out.flush();
25938 output = new String(baos.toByteArray());
25939
25940 System.setOut(systemOut);
25941
25942 outputLines = GrouperClientUtils.splitTrim(output, "\n");
25943
25944
25945
25946 pattern = Pattern
25947 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25948
25949 assertEquals(0, GrouperUtil.length(outputLines));
25950 fail("Shouldnt get here");
25951
25952 } catch (Exception e) {
25953
25954 } finally {
25955
25956 System.setOut(systemOut);
25957
25958 }
25959
25960 assertTrue(GrouperClientWs.mostRecentRequest,
25961 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25962 assertTrue(GrouperClientWs.mostRecentRequest,
25963 !GrouperClientWs.mostRecentRequest.contains("actions"));
25964 assertTrue(GrouperClientWs.mostRecentRequest,
25965 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25966 assertTrue(GrouperClientWs.mostRecentRequest,
25967 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25968 assertTrue(GrouperClientWs.mostRecentRequest,
25969 !GrouperClientWs.mostRecentRequest.contains("enabled"));
25970 assertTrue(GrouperClientWs.mostRecentRequest,
25971 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25972 assertTrue(GrouperClientWs.mostRecentRequest,
25973 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25974 assertTrue(GrouperClientWs.mostRecentRequest,
25975 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25976 assertTrue(GrouperClientWs.mostRecentRequest,
25977 !GrouperClientWs.mostRecentRequest.contains("params"));
25978 assertTrue(GrouperClientWs.mostRecentRequest,
25979 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25980 assertTrue(GrouperClientWs.mostRecentRequest,
25981 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25982 assertFalse(GrouperClientWs.mostRecentRequest,
25983 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25984 assertFalse(GrouperClientWs.mostRecentRequest,
25985 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25986 assertTrue(GrouperClientWs.mostRecentRequest,
25987 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25988 assertTrue(GrouperClientWs.mostRecentRequest,
25989 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25990 assertTrue(GrouperClientWs.mostRecentRequest,
25991 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25992 assertTrue(GrouperClientWs.mostRecentRequest,
25993 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25994 assertTrue(GrouperClientWs.mostRecentRequest,
25995 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25996 assertTrue(GrouperClientWs.mostRecentRequest,
25997 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25998 assertTrue(GrouperClientWs.mostRecentRequest,
25999 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26000 assertFalse(GrouperClientWs.mostRecentRequest,
26001 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26002 assertFalse(GrouperClientWs.mostRecentRequest,
26003 GrouperClientWs.mostRecentRequest.contains("theValue"));
26004 assertFalse(GrouperClientWs.mostRecentRequest,
26005 GrouperClientWs.mostRecentRequest.contains(">123<"));
26006 assertFalse(GrouperClientWs.mostRecentRequest,
26007 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26008 assertFalse(GrouperClientWs.mostRecentRequest,
26009 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26010 assertTrue(GrouperClientWs.mostRecentRequest,
26011 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26012 assertTrue(GrouperClientWs.mostRecentRequest,
26013 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26014 assertTrue(GrouperClientWs.mostRecentRequest,
26015 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26016 assertTrue(GrouperClientWs.mostRecentRequest,
26017 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26018
26019
26020
26021
26022
26023 baos = new ByteArrayOutputStream();
26024 System.setOut(new PrintStream(baos));
26025
26026 GrouperClient.main(GrouperClientUtils.splitTrim(
26027 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
26028 ,
26029 " "));
26030
26031 System.out.flush();
26032 output = new String(baos.toByteArray());
26033
26034 System.setOut(systemOut);
26035
26036 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26037
26038
26039
26040 pattern = Pattern
26041 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26042
26043 assertEquals(1, GrouperUtil.length(outputLines));
26044
26045 outputLine = outputLines[0];
26046
26047 matcher = pattern.matcher(outputLine);
26048
26049 assertTrue(outputLine, matcher.matches());
26050 assertEquals(outputLine, "0", matcher.group(1));
26051 assertEquals(outputLine, "stem_asgn", matcher.group(2));
26052 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26053 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26054 assertEquals(outputLine, "assign", matcher.group(5));
26055 assertEquals(outputLine, "123", matcher.group(6));
26056 assertEquals(outputLine, "T", matcher.group(7));
26057 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26058
26059 assertTrue(GrouperClientWs.mostRecentRequest,
26060 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26061 assertTrue(GrouperClientWs.mostRecentRequest,
26062 !GrouperClientWs.mostRecentRequest.contains("actions"));
26063 assertTrue(GrouperClientWs.mostRecentRequest,
26064 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26065 assertTrue(GrouperClientWs.mostRecentRequest,
26066 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26067 assertTrue(GrouperClientWs.mostRecentRequest,
26068 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26069 assertTrue(GrouperClientWs.mostRecentRequest,
26070 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26071 assertTrue(GrouperClientWs.mostRecentRequest,
26072 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26073 assertTrue(GrouperClientWs.mostRecentRequest,
26074 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26075 assertTrue(GrouperClientWs.mostRecentRequest,
26076 !GrouperClientWs.mostRecentRequest.contains("params"));
26077 assertTrue(GrouperClientWs.mostRecentRequest,
26078 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26079 assertTrue(GrouperClientWs.mostRecentRequest,
26080 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26081 assertFalse(GrouperClientWs.mostRecentRequest,
26082 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26083 assertTrue(GrouperClientWs.mostRecentRequest,
26084 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26085 assertTrue(GrouperClientWs.mostRecentRequest,
26086 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26087 assertTrue(GrouperClientWs.mostRecentRequest,
26088 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26089 assertTrue(GrouperClientWs.mostRecentRequest,
26090 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26091 assertTrue(GrouperClientWs.mostRecentRequest,
26092 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26093 assertTrue(GrouperClientWs.mostRecentRequest,
26094 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26095 assertTrue(GrouperClientWs.mostRecentRequest,
26096 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26097 assertTrue(GrouperClientWs.mostRecentRequest,
26098 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26099 assertFalse(GrouperClientWs.mostRecentRequest,
26100 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26101 assertFalse(GrouperClientWs.mostRecentRequest,
26102 GrouperClientWs.mostRecentRequest.contains("theValue"));
26103 assertFalse(GrouperClientWs.mostRecentRequest,
26104 GrouperClientWs.mostRecentRequest.contains(">123<"));
26105 assertFalse(GrouperClientWs.mostRecentRequest,
26106 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26107 assertFalse(GrouperClientWs.mostRecentRequest,
26108 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26109 assertTrue(GrouperClientWs.mostRecentRequest,
26110 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26111 assertTrue(GrouperClientWs.mostRecentRequest,
26112 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26113 assertTrue(GrouperClientWs.mostRecentRequest,
26114 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26115 assertTrue(GrouperClientWs.mostRecentRequest,
26116 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26117
26118
26119
26120
26121
26122
26123 baos = new ByteArrayOutputStream();
26124 System.setOut(new PrintStream(baos));
26125
26126 try {
26127 GrouperClient.main(GrouperClientUtils.splitTrim(
26128 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
26129 ,
26130 " "));
26131
26132 System.out.flush();
26133 output = new String(baos.toByteArray());
26134
26135 System.setOut(systemOut);
26136
26137 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26138
26139
26140
26141 pattern = Pattern
26142 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26143
26144 assertEquals(1, GrouperUtil.length(outputLines));
26145 fail("Shouldnt get here");
26146 } catch (Exception e) {
26147
26148 } finally {
26149
26150 System.setOut(systemOut);
26151
26152 }
26153
26154 assertTrue(GrouperClientWs.mostRecentRequest,
26155 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26156 assertTrue(GrouperClientWs.mostRecentRequest,
26157 !GrouperClientWs.mostRecentRequest.contains("actions"));
26158 assertTrue(GrouperClientWs.mostRecentRequest,
26159 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26160 assertTrue(GrouperClientWs.mostRecentRequest,
26161 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26162 assertTrue(GrouperClientWs.mostRecentRequest,
26163 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26164 assertTrue(GrouperClientWs.mostRecentRequest,
26165 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26166 assertTrue(GrouperClientWs.mostRecentRequest,
26167 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26168 assertTrue(GrouperClientWs.mostRecentRequest,
26169 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26170 assertTrue(GrouperClientWs.mostRecentRequest,
26171 !GrouperClientWs.mostRecentRequest.contains("params"));
26172 assertTrue(GrouperClientWs.mostRecentRequest,
26173 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26174 assertTrue(GrouperClientWs.mostRecentRequest,
26175 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26176 assertFalse(GrouperClientWs.mostRecentRequest,
26177 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26178 assertTrue(GrouperClientWs.mostRecentRequest,
26179 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26180 assertTrue(GrouperClientWs.mostRecentRequest,
26181 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26182 assertTrue(GrouperClientWs.mostRecentRequest,
26183 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26184 assertTrue(GrouperClientWs.mostRecentRequest,
26185 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26186 assertTrue(GrouperClientWs.mostRecentRequest,
26187 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26188 assertTrue(GrouperClientWs.mostRecentRequest,
26189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26190 assertTrue(GrouperClientWs.mostRecentRequest,
26191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26192 assertTrue(GrouperClientWs.mostRecentRequest,
26193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26194 assertFalse(GrouperClientWs.mostRecentRequest,
26195 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26196 assertFalse(GrouperClientWs.mostRecentRequest,
26197 GrouperClientWs.mostRecentRequest.contains("theValue"));
26198 assertFalse(GrouperClientWs.mostRecentRequest,
26199 GrouperClientWs.mostRecentRequest.contains(">123<"));
26200 assertFalse(GrouperClientWs.mostRecentRequest,
26201 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26202 assertFalse(GrouperClientWs.mostRecentRequest,
26203 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26204 assertTrue(GrouperClientWs.mostRecentRequest,
26205 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26206 assertTrue(GrouperClientWs.mostRecentRequest,
26207 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26208 assertTrue(GrouperClientWs.mostRecentRequest,
26209 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26210 assertTrue(GrouperClientWs.mostRecentRequest,
26211 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26212
26213
26214
26215
26216
26217 baos = new ByteArrayOutputStream();
26218 System.setOut(new PrintStream(baos));
26219
26220 GrouperClient.main(GrouperClientUtils.splitTrim(
26221 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
26222 + " --assignAssignOwnerActions=assign",
26223 " "));
26224
26225 System.out.flush();
26226 output = new String(baos.toByteArray());
26227
26228 System.setOut(systemOut);
26229
26230 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26231
26232
26233
26234 pattern = Pattern
26235 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26236
26237 assertEquals(1, GrouperUtil.length(outputLines));
26238
26239 outputLine = outputLines[0];
26240
26241 matcher = pattern.matcher(outputLine);
26242
26243 assertTrue(outputLine, matcher.matches());
26244 assertEquals(outputLine, "0", matcher.group(1));
26245 assertEquals(outputLine, "stem_asgn", matcher.group(2));
26246 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26247 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26248 assertEquals(outputLine, "assign", matcher.group(5));
26249 assertEquals(outputLine, "123", matcher.group(6));
26250 assertEquals(outputLine, "T", matcher.group(7));
26251 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26252
26253 assertTrue(GrouperClientWs.mostRecentRequest,
26254 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26255 assertTrue(GrouperClientWs.mostRecentRequest,
26256 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
26257 assertTrue(GrouperClientWs.mostRecentRequest,
26258 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26259 assertTrue(GrouperClientWs.mostRecentRequest,
26260 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26261 assertTrue(GrouperClientWs.mostRecentRequest,
26262 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26263 assertTrue(GrouperClientWs.mostRecentRequest,
26264 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26265 assertTrue(GrouperClientWs.mostRecentRequest,
26266 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26267 assertTrue(GrouperClientWs.mostRecentRequest,
26268 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26269 assertTrue(GrouperClientWs.mostRecentRequest,
26270 !GrouperClientWs.mostRecentRequest.contains("params"));
26271 assertTrue(GrouperClientWs.mostRecentRequest,
26272 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26273 assertTrue(GrouperClientWs.mostRecentRequest,
26274 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26275 assertFalse(GrouperClientWs.mostRecentRequest,
26276 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26277 assertTrue(GrouperClientWs.mostRecentRequest,
26278 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26279 assertTrue(GrouperClientWs.mostRecentRequest,
26280 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26281 assertTrue(GrouperClientWs.mostRecentRequest,
26282 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26283 assertTrue(GrouperClientWs.mostRecentRequest,
26284 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26285 assertTrue(GrouperClientWs.mostRecentRequest,
26286 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26287 assertTrue(GrouperClientWs.mostRecentRequest,
26288 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26289 assertTrue(GrouperClientWs.mostRecentRequest,
26290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26291 assertTrue(GrouperClientWs.mostRecentRequest,
26292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26293 assertFalse(GrouperClientWs.mostRecentRequest,
26294 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26295 assertFalse(GrouperClientWs.mostRecentRequest,
26296 GrouperClientWs.mostRecentRequest.contains("theValue"));
26297 assertFalse(GrouperClientWs.mostRecentRequest,
26298 GrouperClientWs.mostRecentRequest.contains(">123<"));
26299 assertFalse(GrouperClientWs.mostRecentRequest,
26300 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26301 assertFalse(GrouperClientWs.mostRecentRequest,
26302 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26303 assertTrue(GrouperClientWs.mostRecentRequest,
26304 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26305 assertTrue(GrouperClientWs.mostRecentRequest,
26306 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26307 assertTrue(GrouperClientWs.mostRecentRequest,
26308 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26309 assertTrue(GrouperClientWs.mostRecentRequest,
26310 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
26311
26312
26313
26314
26315
26316 baos = new ByteArrayOutputStream();
26317 System.setOut(new PrintStream(baos));
26318
26319 GrouperClient.main(GrouperClientUtils.splitTrim(
26320 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
26321 + " --assignAssignOwnerActions=assign2",
26322 " "));
26323
26324 System.out.flush();
26325 output = new String(baos.toByteArray());
26326
26327 System.setOut(systemOut);
26328
26329 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26330
26331
26332
26333 pattern = Pattern
26334 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26335
26336 assertEquals(0, GrouperUtil.length(outputLines));
26337
26338 assertTrue(GrouperClientWs.mostRecentRequest,
26339 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26340 assertTrue(GrouperClientWs.mostRecentRequest,
26341 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
26342 assertTrue(GrouperClientWs.mostRecentRequest,
26343 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26344 assertTrue(GrouperClientWs.mostRecentRequest,
26345 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26346 assertTrue(GrouperClientWs.mostRecentRequest,
26347 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26348 assertTrue(GrouperClientWs.mostRecentRequest,
26349 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26350 assertTrue(GrouperClientWs.mostRecentRequest,
26351 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26352 assertTrue(GrouperClientWs.mostRecentRequest,
26353 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26354 assertTrue(GrouperClientWs.mostRecentRequest,
26355 !GrouperClientWs.mostRecentRequest.contains("params"));
26356 assertTrue(GrouperClientWs.mostRecentRequest,
26357 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26358 assertTrue(GrouperClientWs.mostRecentRequest,
26359 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26360 assertFalse(GrouperClientWs.mostRecentRequest,
26361 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26362 assertTrue(GrouperClientWs.mostRecentRequest,
26363 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26364 assertTrue(GrouperClientWs.mostRecentRequest,
26365 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26366 assertTrue(GrouperClientWs.mostRecentRequest,
26367 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26368 assertTrue(GrouperClientWs.mostRecentRequest,
26369 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26370 assertTrue(GrouperClientWs.mostRecentRequest,
26371 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26372 assertTrue(GrouperClientWs.mostRecentRequest,
26373 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26374 assertTrue(GrouperClientWs.mostRecentRequest,
26375 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26376 assertTrue(GrouperClientWs.mostRecentRequest,
26377 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26378 assertFalse(GrouperClientWs.mostRecentRequest,
26379 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26380 assertFalse(GrouperClientWs.mostRecentRequest,
26381 GrouperClientWs.mostRecentRequest.contains("theValue"));
26382 assertFalse(GrouperClientWs.mostRecentRequest,
26383 GrouperClientWs.mostRecentRequest.contains(">123<"));
26384 assertFalse(GrouperClientWs.mostRecentRequest,
26385 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26386 assertFalse(GrouperClientWs.mostRecentRequest,
26387 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26388 assertTrue(GrouperClientWs.mostRecentRequest,
26389 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26390 assertTrue(GrouperClientWs.mostRecentRequest,
26391 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26392 assertTrue(GrouperClientWs.mostRecentRequest,
26393 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26394 assertTrue(GrouperClientWs.mostRecentRequest,
26395 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
26396
26397
26398
26399
26400
26401
26402 baos = new ByteArrayOutputStream();
26403 System.setOut(new PrintStream(baos));
26404
26405 GrouperClient.main(GrouperClientUtils.splitTrim(
26406 "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --ownerStemNames=" + stem.getName()
26407 ,
26408 " "));
26409
26410 System.out.flush();
26411 output = new String(baos.toByteArray());
26412
26413 System.setOut(systemOut);
26414
26415 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26416
26417
26418
26419 pattern = Pattern
26420 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26421
26422 assertEquals(1, GrouperUtil.length(outputLines));
26423
26424 outputLine = outputLines[0];
26425
26426 matcher = pattern.matcher(outputLine);
26427
26428 assertTrue(outputLine, matcher.matches());
26429 assertEquals(outputLine, "0", matcher.group(1));
26430 assertEquals(outputLine, "stem_asgn", matcher.group(2));
26431 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26432 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26433 assertEquals(outputLine, "assign", matcher.group(5));
26434 assertEquals(outputLine, "123", matcher.group(6));
26435 assertEquals(outputLine, "T", matcher.group(7));
26436 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26437
26438 assertTrue(GrouperClientWs.mostRecentRequest,
26439 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26440 assertTrue(GrouperClientWs.mostRecentRequest,
26441 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
26442 assertTrue(GrouperClientWs.mostRecentRequest,
26443 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26444 assertTrue(GrouperClientWs.mostRecentRequest,
26445 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26446 assertTrue(GrouperClientWs.mostRecentRequest,
26447 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26448 assertTrue(GrouperClientWs.mostRecentRequest,
26449 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26450 assertTrue(GrouperClientWs.mostRecentRequest,
26451 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26452 assertTrue(GrouperClientWs.mostRecentRequest,
26453 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26454 assertTrue(GrouperClientWs.mostRecentRequest,
26455 !GrouperClientWs.mostRecentRequest.contains("params"));
26456 assertTrue(GrouperClientWs.mostRecentRequest,
26457 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26458 assertTrue(GrouperClientWs.mostRecentRequest,
26459 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26460 assertFalse(GrouperClientWs.mostRecentRequest,
26461 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26462 assertFalse(GrouperClientWs.mostRecentRequest,
26463 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26464 assertTrue(GrouperClientWs.mostRecentRequest,
26465 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26466 assertTrue(GrouperClientWs.mostRecentRequest,
26467 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26468 assertTrue(GrouperClientWs.mostRecentRequest,
26469 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26470 assertTrue(GrouperClientWs.mostRecentRequest,
26471 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26472 assertTrue(GrouperClientWs.mostRecentRequest,
26473 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26474 assertTrue(GrouperClientWs.mostRecentRequest,
26475 GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26476 assertTrue(GrouperClientWs.mostRecentRequest,
26477 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26478 assertFalse(GrouperClientWs.mostRecentRequest,
26479 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26480 assertFalse(GrouperClientWs.mostRecentRequest,
26481 GrouperClientWs.mostRecentRequest.contains("theValue"));
26482 assertFalse(GrouperClientWs.mostRecentRequest,
26483 GrouperClientWs.mostRecentRequest.contains(">123<"));
26484 assertFalse(GrouperClientWs.mostRecentRequest,
26485 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26486 assertFalse(GrouperClientWs.mostRecentRequest,
26487 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26488 assertTrue(GrouperClientWs.mostRecentRequest,
26489 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26490 assertTrue(GrouperClientWs.mostRecentRequest,
26491 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26492 assertTrue(GrouperClientWs.mostRecentRequest,
26493 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26494 assertTrue(GrouperClientWs.mostRecentRequest,
26495 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
26496
26497
26498 } finally {
26499 System.setOut(systemOut);
26500 }
26501
26502 }
26503
26504
26505
26506
26507 public void testGetAttributeAssignsMemberExtraFeatures() throws Exception {
26508
26509 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
26510 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
26511
26512 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
26513
26514 attributeDef.setValueType(AttributeDefValueType.string);
26515 attributeDef.setAssignToMember(true);
26516 attributeDef.store();
26517
26518 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
26519
26520 attributeDef2.setAssignToGroup(false);
26521 attributeDef2.setAssignToMemberAssn(true);
26522 attributeDef2.setValueType(AttributeDefValueType.integer);
26523 attributeDef2.store();
26524
26525 Member member = MemberFinder.findBySubject(GrouperSession.staticGrouperSession(), SubjectTestHelper.SUBJ0, true);
26526
26527 AttributeAssignResult attributeAssignResult = member.getAttributeDelegate().assignAttribute(attributeDefName);
26528 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
26529 attributeAssign.getValueDelegate().assignValue("abc");
26530
26531 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
26532 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
26533 attributeAssign2.getValueDelegate().assignValue("123");
26534
26535 PrintStream systemOut = System.out;
26536
26537 ByteArrayOutputStream baos = new ByteArrayOutputStream();
26538 System.setOut(new PrintStream(baos));
26539
26540 try {
26541
26542 GrouperClient.main(GrouperClientUtils.splitTrim(
26543 "--operation=getAttributeAssignmentsWs --attributeAssignType=member " +
26544 "--attributeDefNames=test:testAttributeAssignDefNameDef " +
26545 "--attributeDefValueType=string --value=abc",
26546 " "));
26547 System.out.flush();
26548 String output = new String(baos.toByteArray());
26549
26550 System.setOut(systemOut);
26551
26552 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
26553
26554
26555
26556 Pattern pattern = Pattern
26557 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26558
26559 assertEquals(1, GrouperUtil.length(outputLines));
26560 String outputLine = outputLines[0];
26561
26562 Matcher matcher = pattern.matcher(outputLines[0]);
26563
26564 assertTrue(outputLine, matcher.matches());
26565 assertEquals(outputLine, "0", matcher.group(1));
26566 assertEquals(outputLine, "member", matcher.group(2));
26567 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
26568 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
26569 assertEquals(outputLine, "assign", matcher.group(5));
26570 assertEquals(outputLine, "abc", matcher.group(6));
26571 assertEquals(outputLine, "T", matcher.group(7));
26572 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
26573
26574 assertTrue(GrouperClientWs.mostRecentRequest,
26575 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26576 assertTrue(GrouperClientWs.mostRecentRequest,
26577 !GrouperClientWs.mostRecentRequest.contains("actions"));
26578 assertTrue(GrouperClientWs.mostRecentRequest,
26579 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26580 assertTrue(GrouperClientWs.mostRecentRequest,
26581 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26582 assertTrue(GrouperClientWs.mostRecentRequest,
26583 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26584 assertTrue(GrouperClientWs.mostRecentRequest,
26585 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26586 assertTrue(GrouperClientWs.mostRecentRequest,
26587 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26588 assertTrue(GrouperClientWs.mostRecentRequest,
26589 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26590 assertTrue(GrouperClientWs.mostRecentRequest,
26591 !GrouperClientWs.mostRecentRequest.contains("params"));
26592 assertTrue(GrouperClientWs.mostRecentRequest,
26593 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26594 assertTrue(GrouperClientWs.mostRecentRequest,
26595 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26596 assertTrue(GrouperClientWs.mostRecentRequest,
26597 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
26598 assertTrue(GrouperClientWs.mostRecentRequest,
26599 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26600 assertTrue(GrouperClientWs.mostRecentRequest,
26601 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26602 assertTrue(GrouperClientWs.mostRecentRequest,
26603 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26604 assertTrue(GrouperClientWs.mostRecentRequest,
26605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26606 assertTrue(GrouperClientWs.mostRecentRequest,
26607 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26608 assertTrue(GrouperClientWs.mostRecentRequest,
26609 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26610 assertTrue(GrouperClientWs.mostRecentRequest,
26611 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26612 assertTrue(GrouperClientWs.mostRecentRequest,
26613 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26614 assertTrue(GrouperClientWs.mostRecentRequest,
26615 GrouperClientWs.mostRecentRequest.contains("theValue"));
26616 assertTrue(GrouperClientWs.mostRecentRequest,
26617 GrouperClientWs.mostRecentRequest.contains("abc"));
26618 assertTrue(GrouperClientWs.mostRecentRequest,
26619 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26620 assertTrue(GrouperClientWs.mostRecentRequest,
26621 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26622 assertTrue(GrouperClientWs.mostRecentRequest,
26623 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26624 assertTrue(GrouperClientWs.mostRecentRequest,
26625 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26626 assertTrue(GrouperClientWs.mostRecentRequest,
26627 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26628 assertTrue(GrouperClientWs.mostRecentRequest,
26629 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26630 assertTrue(GrouperClientWs.mostRecentRequest,
26631 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26632 assertTrue(GrouperClientWs.mostRecentRequest,
26633 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26634
26635
26636
26637
26638 baos = new ByteArrayOutputStream();
26639 System.setOut(new PrintStream(baos));
26640
26641 GrouperClient.main(GrouperClientUtils.splitTrim(
26642 "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=" + attributeDef.getId() +
26643 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
26644 "--attributeDefValueType=string --value=123",
26645 " "));
26646
26647
26648 System.out.flush();
26649 output = new String(baos.toByteArray());
26650
26651 System.setOut(systemOut);
26652
26653 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26654
26655 assertEquals(0, GrouperUtil.length(outputLines));
26656
26657
26658
26659
26660 assertTrue(GrouperClientWs.mostRecentRequest,
26661 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26662 assertTrue(GrouperClientWs.mostRecentRequest,
26663 !GrouperClientWs.mostRecentRequest.contains("actions"));
26664 assertTrue(GrouperClientWs.mostRecentRequest,
26665 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26666 assertTrue(GrouperClientWs.mostRecentRequest,
26667 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26668 assertTrue(GrouperClientWs.mostRecentRequest,
26669 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26670 assertTrue(GrouperClientWs.mostRecentRequest,
26671 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26672 assertTrue(GrouperClientWs.mostRecentRequest,
26673 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26674 assertTrue(GrouperClientWs.mostRecentRequest,
26675 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26676 assertTrue(GrouperClientWs.mostRecentRequest,
26677 !GrouperClientWs.mostRecentRequest.contains("params"));
26678 assertTrue(GrouperClientWs.mostRecentRequest,
26679 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26680 assertTrue(GrouperClientWs.mostRecentRequest,
26681 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26682 assertTrue(GrouperClientWs.mostRecentRequest,
26683 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
26684 assertTrue(GrouperClientWs.mostRecentRequest,
26685 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26686 assertTrue(GrouperClientWs.mostRecentRequest,
26687 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26688 assertTrue(GrouperClientWs.mostRecentRequest,
26689 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26690 assertTrue(GrouperClientWs.mostRecentRequest,
26691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26692 assertTrue(GrouperClientWs.mostRecentRequest,
26693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26694 assertTrue(GrouperClientWs.mostRecentRequest,
26695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26696 assertTrue(GrouperClientWs.mostRecentRequest,
26697 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26698 assertTrue(GrouperClientWs.mostRecentRequest,
26699 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26700 assertTrue(GrouperClientWs.mostRecentRequest,
26701 GrouperClientWs.mostRecentRequest.contains("theValue"));
26702 assertTrue(GrouperClientWs.mostRecentRequest,
26703 GrouperClientWs.mostRecentRequest.contains(">123<"));
26704 assertTrue(GrouperClientWs.mostRecentRequest,
26705 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26706 assertTrue(GrouperClientWs.mostRecentRequest,
26707 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26708 assertTrue(GrouperClientWs.mostRecentRequest,
26709 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26710 assertTrue(GrouperClientWs.mostRecentRequest,
26711 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26712 assertTrue(GrouperClientWs.mostRecentRequest,
26713 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26714 assertTrue(GrouperClientWs.mostRecentRequest,
26715 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26716 assertTrue(GrouperClientWs.mostRecentRequest,
26717 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26718 assertTrue(GrouperClientWs.mostRecentRequest,
26719 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26720
26721
26722
26723
26724
26725 baos = new ByteArrayOutputStream();
26726 System.setOut(new PrintStream(baos));
26727
26728 try {
26729 GrouperClient.main(GrouperClientUtils.splitTrim(
26730 " --operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=123" + attributeDef.getId() +
26731 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
26732 "--attributeDefValueType=string --value=123",
26733 " "));
26734 fail("Shouldnt get here");
26735 } catch (GcWebServiceError gwse) {
26736
26737 }
26738
26739
26740
26741
26742 baos = new ByteArrayOutputStream();
26743 System.setOut(new PrintStream(baos));
26744
26745 GrouperClient.main(GrouperClientUtils.splitTrim(
26746 "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=" + attributeDef.getId() +
26747 " --attributeDefValueType=string --value=abc --attributeDefType=attr",
26748 " "));
26749
26750
26751 System.out.flush();
26752 output = new String(baos.toByteArray());
26753
26754 System.setOut(systemOut);
26755
26756 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26757
26758
26759
26760 pattern = Pattern
26761 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26762
26763 assertEquals(1, GrouperUtil.length(outputLines));
26764 outputLine = outputLines[0];
26765
26766 matcher = pattern.matcher(outputLines[0]);
26767
26768 assertTrue(outputLine, matcher.matches());
26769 assertEquals(outputLine, "0", matcher.group(1));
26770 assertEquals(outputLine, "member", matcher.group(2));
26771 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
26772 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
26773 assertEquals(outputLine, "assign", matcher.group(5));
26774 assertEquals(outputLine, "abc", matcher.group(6));
26775 assertEquals(outputLine, "T", matcher.group(7));
26776 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
26777
26778 assertTrue(GrouperClientWs.mostRecentRequest,
26779 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26780 assertTrue(GrouperClientWs.mostRecentRequest,
26781 !GrouperClientWs.mostRecentRequest.contains("actions"));
26782 assertTrue(GrouperClientWs.mostRecentRequest,
26783 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26784 assertTrue(GrouperClientWs.mostRecentRequest,
26785 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26786 assertTrue(GrouperClientWs.mostRecentRequest,
26787 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26788 assertTrue(GrouperClientWs.mostRecentRequest,
26789 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26790 assertTrue(GrouperClientWs.mostRecentRequest,
26791 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26792 assertTrue(GrouperClientWs.mostRecentRequest,
26793 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26794 assertTrue(GrouperClientWs.mostRecentRequest,
26795 !GrouperClientWs.mostRecentRequest.contains("params"));
26796 assertTrue(GrouperClientWs.mostRecentRequest,
26797 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26798 assertTrue(GrouperClientWs.mostRecentRequest,
26799 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26800 assertTrue(GrouperClientWs.mostRecentRequest,
26801 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26802 assertTrue(GrouperClientWs.mostRecentRequest,
26803 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26804 assertTrue(GrouperClientWs.mostRecentRequest,
26805 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26806 assertTrue(GrouperClientWs.mostRecentRequest,
26807 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26808 assertTrue(GrouperClientWs.mostRecentRequest,
26809 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26810 assertTrue(GrouperClientWs.mostRecentRequest,
26811 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26812 assertTrue(GrouperClientWs.mostRecentRequest,
26813 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26814 assertTrue(GrouperClientWs.mostRecentRequest,
26815 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26816 assertTrue(GrouperClientWs.mostRecentRequest,
26817 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26818 assertTrue(GrouperClientWs.mostRecentRequest,
26819 GrouperClientWs.mostRecentRequest.contains("theValue"));
26820 assertTrue(GrouperClientWs.mostRecentRequest,
26821 GrouperClientWs.mostRecentRequest.contains("abc"));
26822 assertTrue(GrouperClientWs.mostRecentRequest,
26823 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26824 assertTrue(GrouperClientWs.mostRecentRequest,
26825 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26826 assertTrue(GrouperClientWs.mostRecentRequest,
26827 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26828 assertTrue(GrouperClientWs.mostRecentRequest,
26829 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26830 assertTrue(GrouperClientWs.mostRecentRequest,
26831 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26832 assertTrue(GrouperClientWs.mostRecentRequest,
26833 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26834 assertTrue(GrouperClientWs.mostRecentRequest,
26835 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26836 assertTrue(GrouperClientWs.mostRecentRequest,
26837 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26838
26839
26840
26841
26842 baos = new ByteArrayOutputStream();
26843 System.setOut(new PrintStream(baos));
26844
26845 GrouperClient.main(GrouperClientUtils.splitTrim(
26846 "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=" + attributeDef.getId() +
26847 " --attributeDefValueType=string --value=abc --attributeDefType=limit",
26848 " "));
26849
26850 System.out.flush();
26851 output = new String(baos.toByteArray());
26852
26853 System.setOut(systemOut);
26854
26855 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26856
26857
26858
26859 pattern = Pattern
26860 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26861
26862 assertEquals(0, GrouperUtil.length(outputLines));
26863
26864 assertTrue(GrouperClientWs.mostRecentRequest,
26865 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26866 assertTrue(GrouperClientWs.mostRecentRequest,
26867 !GrouperClientWs.mostRecentRequest.contains("actions"));
26868 assertTrue(GrouperClientWs.mostRecentRequest,
26869 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26870 assertTrue(GrouperClientWs.mostRecentRequest,
26871 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26872 assertTrue(GrouperClientWs.mostRecentRequest,
26873 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26874 assertTrue(GrouperClientWs.mostRecentRequest,
26875 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26876 assertTrue(GrouperClientWs.mostRecentRequest,
26877 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26878 assertTrue(GrouperClientWs.mostRecentRequest,
26879 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26880 assertTrue(GrouperClientWs.mostRecentRequest,
26881 !GrouperClientWs.mostRecentRequest.contains("params"));
26882 assertTrue(GrouperClientWs.mostRecentRequest,
26883 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26884 assertTrue(GrouperClientWs.mostRecentRequest,
26885 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26886 assertTrue(GrouperClientWs.mostRecentRequest,
26887 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26888 assertTrue(GrouperClientWs.mostRecentRequest,
26889 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26890 assertTrue(GrouperClientWs.mostRecentRequest,
26891 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26892 assertTrue(GrouperClientWs.mostRecentRequest,
26893 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26894 assertTrue(GrouperClientWs.mostRecentRequest,
26895 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26896 assertTrue(GrouperClientWs.mostRecentRequest,
26897 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26898 assertTrue(GrouperClientWs.mostRecentRequest,
26899 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26900 assertTrue(GrouperClientWs.mostRecentRequest,
26901 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26902 assertTrue(GrouperClientWs.mostRecentRequest,
26903 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26904 assertTrue(GrouperClientWs.mostRecentRequest,
26905 GrouperClientWs.mostRecentRequest.contains("theValue"));
26906 assertTrue(GrouperClientWs.mostRecentRequest,
26907 GrouperClientWs.mostRecentRequest.contains("abc"));
26908 assertTrue(GrouperClientWs.mostRecentRequest,
26909 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26910 assertTrue(GrouperClientWs.mostRecentRequest,
26911 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26912 assertTrue(GrouperClientWs.mostRecentRequest,
26913 GrouperClientWs.mostRecentRequest.contains("limit"));
26914 assertTrue(GrouperClientWs.mostRecentRequest,
26915 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26916 assertTrue(GrouperClientWs.mostRecentRequest,
26917 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26918 assertTrue(GrouperClientWs.mostRecentRequest,
26919 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26920 assertTrue(GrouperClientWs.mostRecentRequest,
26921 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26922 assertTrue(GrouperClientWs.mostRecentRequest,
26923 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26924 assertTrue(GrouperClientWs.mostRecentRequest,
26925 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26926
26927
26928
26929
26930 baos = new ByteArrayOutputStream();
26931 System.setOut(new PrintStream(baos));
26932
26933 GrouperClient.main(GrouperClientUtils.splitTrim(
26934 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId(),
26935 " "));
26936
26937 System.out.flush();
26938 output = new String(baos.toByteArray());
26939
26940 System.setOut(systemOut);
26941
26942 outputLines = GrouperClientUtils.splitTrim(output, "\n");
26943
26944
26945
26946 pattern = Pattern
26947 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26948
26949 assertEquals(1, GrouperUtil.length(outputLines));
26950 outputLine = outputLines[0];
26951
26952 matcher = pattern.matcher(outputLines[0]);
26953
26954 assertTrue(outputLine, matcher.matches());
26955 assertEquals(outputLine, "0", matcher.group(1));
26956 assertEquals(outputLine, "mem_asgn", matcher.group(2));
26957 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26958 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26959 assertEquals(outputLine, "assign", matcher.group(5));
26960 assertEquals(outputLine, "123", matcher.group(6));
26961 assertEquals(outputLine, "T", matcher.group(7));
26962 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26963
26964 assertTrue(GrouperClientWs.mostRecentRequest,
26965 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26966 assertTrue(GrouperClientWs.mostRecentRequest,
26967 !GrouperClientWs.mostRecentRequest.contains("actions"));
26968 assertTrue(GrouperClientWs.mostRecentRequest,
26969 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26970 assertTrue(GrouperClientWs.mostRecentRequest,
26971 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26972 assertTrue(GrouperClientWs.mostRecentRequest,
26973 !GrouperClientWs.mostRecentRequest.contains("enabled"));
26974 assertTrue(GrouperClientWs.mostRecentRequest,
26975 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26976 assertTrue(GrouperClientWs.mostRecentRequest,
26977 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26978 assertTrue(GrouperClientWs.mostRecentRequest,
26979 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26980 assertTrue(GrouperClientWs.mostRecentRequest,
26981 !GrouperClientWs.mostRecentRequest.contains("params"));
26982 assertTrue(GrouperClientWs.mostRecentRequest,
26983 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26984 assertTrue(GrouperClientWs.mostRecentRequest,
26985 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26986 assertTrue(GrouperClientWs.mostRecentRequest,
26987 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26988 assertTrue(GrouperClientWs.mostRecentRequest,
26989 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26990 assertTrue(GrouperClientWs.mostRecentRequest,
26991 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26992 assertTrue(GrouperClientWs.mostRecentRequest,
26993 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26994 assertTrue(GrouperClientWs.mostRecentRequest,
26995 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26996 assertTrue(GrouperClientWs.mostRecentRequest,
26997 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26998 assertTrue(GrouperClientWs.mostRecentRequest,
26999 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27000 assertTrue(GrouperClientWs.mostRecentRequest,
27001 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27002 assertFalse(GrouperClientWs.mostRecentRequest,
27003 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27004 assertFalse(GrouperClientWs.mostRecentRequest,
27005 GrouperClientWs.mostRecentRequest.contains("theValue"));
27006 assertFalse(GrouperClientWs.mostRecentRequest,
27007 GrouperClientWs.mostRecentRequest.contains(">abc<"));
27008 assertTrue(GrouperClientWs.mostRecentRequest,
27009 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27010 assertFalse(GrouperClientWs.mostRecentRequest,
27011 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27012 assertTrue(GrouperClientWs.mostRecentRequest,
27013 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27014 assertTrue(GrouperClientWs.mostRecentRequest,
27015 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27016 assertTrue(GrouperClientWs.mostRecentRequest,
27017 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27018 assertTrue(GrouperClientWs.mostRecentRequest,
27019 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27020 assertTrue(GrouperClientWs.mostRecentRequest,
27021 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27022 assertTrue(GrouperClientWs.mostRecentRequest,
27023 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27024
27025
27026
27027
27028 baos = new ByteArrayOutputStream();
27029 System.setOut(new PrintStream(baos));
27030
27031 try {
27032 GrouperClient.main(GrouperClientUtils.splitTrim(
27033 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
27034 " "));
27035
27036 System.out.flush();
27037 output = new String(baos.toByteArray());
27038
27039 System.setOut(systemOut);
27040
27041 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27042
27043
27044
27045 pattern = Pattern
27046 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27047
27048 assertEquals(0, GrouperUtil.length(outputLines));
27049 fail("Why did it not fail?");
27050 } catch (Exception e) {
27051
27052 }
27053 assertTrue(GrouperClientWs.mostRecentRequest,
27054 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27055 assertTrue(GrouperClientWs.mostRecentRequest,
27056 !GrouperClientWs.mostRecentRequest.contains("actions"));
27057 assertTrue(GrouperClientWs.mostRecentRequest,
27058 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27059 assertTrue(GrouperClientWs.mostRecentRequest,
27060 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27061 assertTrue(GrouperClientWs.mostRecentRequest,
27062 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27063 assertTrue(GrouperClientWs.mostRecentRequest,
27064 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27065 assertTrue(GrouperClientWs.mostRecentRequest,
27066 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27067 assertTrue(GrouperClientWs.mostRecentRequest,
27068 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27069 assertTrue(GrouperClientWs.mostRecentRequest,
27070 !GrouperClientWs.mostRecentRequest.contains("params"));
27071 assertTrue(GrouperClientWs.mostRecentRequest,
27072 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27073 assertTrue(GrouperClientWs.mostRecentRequest,
27074 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27075 assertTrue(GrouperClientWs.mostRecentRequest,
27076 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27077 assertTrue(GrouperClientWs.mostRecentRequest,
27078 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27079 assertTrue(GrouperClientWs.mostRecentRequest,
27080 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27081 assertTrue(GrouperClientWs.mostRecentRequest,
27082 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27083 assertTrue(GrouperClientWs.mostRecentRequest,
27084 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27085 assertTrue(GrouperClientWs.mostRecentRequest,
27086 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27087 assertTrue(GrouperClientWs.mostRecentRequest,
27088 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27089 assertTrue(GrouperClientWs.mostRecentRequest,
27090 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27091 assertFalse(GrouperClientWs.mostRecentRequest,
27092 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27093 assertFalse(GrouperClientWs.mostRecentRequest,
27094 GrouperClientWs.mostRecentRequest.contains("theValue"));
27095 assertFalse(GrouperClientWs.mostRecentRequest,
27096 GrouperClientWs.mostRecentRequest.contains("abc"));
27097 assertTrue(GrouperClientWs.mostRecentRequest,
27098 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27099 assertFalse(GrouperClientWs.mostRecentRequest,
27100 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27101 assertTrue(GrouperClientWs.mostRecentRequest,
27102 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27103 assertTrue(GrouperClientWs.mostRecentRequest,
27104 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27105 assertTrue(GrouperClientWs.mostRecentRequest,
27106 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27107 assertTrue(GrouperClientWs.mostRecentRequest,
27108 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27109 assertTrue(GrouperClientWs.mostRecentRequest,
27110 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27111 assertTrue(GrouperClientWs.mostRecentRequest,
27112 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27113
27114
27115
27116
27117
27118 baos = new ByteArrayOutputStream();
27119 System.setOut(new PrintStream(baos));
27120
27121 GrouperClient.main(GrouperClientUtils.splitTrim(
27122 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId()
27123 + " --attributeDefValueType=integer --value=123 ",
27124 " "));
27125
27126 System.out.flush();
27127 output = new String(baos.toByteArray());
27128
27129 System.setOut(systemOut);
27130
27131 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27132
27133
27134
27135 pattern = Pattern
27136 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27137
27138 assertEquals(1, GrouperUtil.length(outputLines));
27139 outputLine = outputLines[0];
27140
27141 matcher = pattern.matcher(outputLines[0]);
27142
27143 assertTrue(outputLine, matcher.matches());
27144 assertEquals(outputLine, "0", matcher.group(1));
27145 assertEquals(outputLine, "mem_asgn", matcher.group(2));
27146 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27147 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27148 assertEquals(outputLine, "assign", matcher.group(5));
27149 assertEquals(outputLine, "123", matcher.group(6));
27150 assertEquals(outputLine, "T", matcher.group(7));
27151 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27152
27153 assertTrue(GrouperClientWs.mostRecentRequest,
27154 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27155 assertTrue(GrouperClientWs.mostRecentRequest,
27156 !GrouperClientWs.mostRecentRequest.contains("actions"));
27157 assertTrue(GrouperClientWs.mostRecentRequest,
27158 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27159 assertTrue(GrouperClientWs.mostRecentRequest,
27160 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27161 assertTrue(GrouperClientWs.mostRecentRequest,
27162 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27163 assertTrue(GrouperClientWs.mostRecentRequest,
27164 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27165 assertTrue(GrouperClientWs.mostRecentRequest,
27166 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27167 assertTrue(GrouperClientWs.mostRecentRequest,
27168 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27169 assertTrue(GrouperClientWs.mostRecentRequest,
27170 !GrouperClientWs.mostRecentRequest.contains("params"));
27171 assertTrue(GrouperClientWs.mostRecentRequest,
27172 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27173 assertTrue(GrouperClientWs.mostRecentRequest,
27174 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27175 assertTrue(GrouperClientWs.mostRecentRequest,
27176 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27177 assertTrue(GrouperClientWs.mostRecentRequest,
27178 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27179 assertTrue(GrouperClientWs.mostRecentRequest,
27180 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27181 assertTrue(GrouperClientWs.mostRecentRequest,
27182 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27183 assertTrue(GrouperClientWs.mostRecentRequest,
27184 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27185 assertTrue(GrouperClientWs.mostRecentRequest,
27186 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27187 assertTrue(GrouperClientWs.mostRecentRequest,
27188 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27189 assertTrue(GrouperClientWs.mostRecentRequest,
27190 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27191 assertTrue(GrouperClientWs.mostRecentRequest,
27192 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27193 assertTrue(GrouperClientWs.mostRecentRequest,
27194 GrouperClientWs.mostRecentRequest.contains("theValue"));
27195 assertTrue(GrouperClientWs.mostRecentRequest,
27196 GrouperClientWs.mostRecentRequest.contains(">123<"));
27197 assertTrue(GrouperClientWs.mostRecentRequest,
27198 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27199 assertFalse(GrouperClientWs.mostRecentRequest,
27200 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27201 assertTrue(GrouperClientWs.mostRecentRequest,
27202 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27203 assertTrue(GrouperClientWs.mostRecentRequest,
27204 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27205 assertTrue(GrouperClientWs.mostRecentRequest,
27206 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27207 assertTrue(GrouperClientWs.mostRecentRequest,
27208 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27209 assertTrue(GrouperClientWs.mostRecentRequest,
27210 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27211 assertTrue(GrouperClientWs.mostRecentRequest,
27212 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27213
27214
27215
27216
27217
27218 baos = new ByteArrayOutputStream();
27219 System.setOut(new PrintStream(baos));
27220
27221 GrouperClient.main(GrouperClientUtils.splitTrim(
27222 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId()
27223 + " --attributeDefValueType=integer --value=1234 ",
27224 " "));
27225
27226 System.out.flush();
27227 output = new String(baos.toByteArray());
27228
27229 System.setOut(systemOut);
27230
27231 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27232
27233
27234
27235 pattern = Pattern
27236 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27237
27238 assertEquals(0, GrouperUtil.length(outputLines));
27239
27240 assertTrue(GrouperClientWs.mostRecentRequest,
27241 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27242 assertTrue(GrouperClientWs.mostRecentRequest,
27243 !GrouperClientWs.mostRecentRequest.contains("actions"));
27244 assertTrue(GrouperClientWs.mostRecentRequest,
27245 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27246 assertTrue(GrouperClientWs.mostRecentRequest,
27247 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27248 assertTrue(GrouperClientWs.mostRecentRequest,
27249 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27250 assertTrue(GrouperClientWs.mostRecentRequest,
27251 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27252 assertTrue(GrouperClientWs.mostRecentRequest,
27253 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27254 assertTrue(GrouperClientWs.mostRecentRequest,
27255 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27256 assertTrue(GrouperClientWs.mostRecentRequest,
27257 !GrouperClientWs.mostRecentRequest.contains("params"));
27258 assertTrue(GrouperClientWs.mostRecentRequest,
27259 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27260 assertTrue(GrouperClientWs.mostRecentRequest,
27261 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27262 assertTrue(GrouperClientWs.mostRecentRequest,
27263 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27264 assertTrue(GrouperClientWs.mostRecentRequest,
27265 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27266 assertTrue(GrouperClientWs.mostRecentRequest,
27267 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27268 assertTrue(GrouperClientWs.mostRecentRequest,
27269 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27270 assertTrue(GrouperClientWs.mostRecentRequest,
27271 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27272 assertTrue(GrouperClientWs.mostRecentRequest,
27273 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27274 assertTrue(GrouperClientWs.mostRecentRequest,
27275 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27276 assertTrue(GrouperClientWs.mostRecentRequest,
27277 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27278 assertTrue(GrouperClientWs.mostRecentRequest,
27279 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27280 assertTrue(GrouperClientWs.mostRecentRequest,
27281 GrouperClientWs.mostRecentRequest.contains("theValue"));
27282 assertTrue(GrouperClientWs.mostRecentRequest,
27283 GrouperClientWs.mostRecentRequest.contains("1234"));
27284 assertTrue(GrouperClientWs.mostRecentRequest,
27285 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27286 assertFalse(GrouperClientWs.mostRecentRequest,
27287 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27288 assertTrue(GrouperClientWs.mostRecentRequest,
27289 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27290 assertTrue(GrouperClientWs.mostRecentRequest,
27291 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27292 assertTrue(GrouperClientWs.mostRecentRequest,
27293 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27294 assertTrue(GrouperClientWs.mostRecentRequest,
27295 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27296 assertTrue(GrouperClientWs.mostRecentRequest,
27297 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27298 assertTrue(GrouperClientWs.mostRecentRequest,
27299 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27300
27301
27302
27303
27304
27305 baos = new ByteArrayOutputStream();
27306 System.setOut(new PrintStream(baos));
27307
27308 GrouperClient.main(GrouperClientUtils.splitTrim(
27309 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId()
27310 + " --includeAssignmentsFromAssignments=T ",
27311 " "));
27312
27313 System.out.flush();
27314 output = new String(baos.toByteArray());
27315
27316 System.setOut(systemOut);
27317
27318 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27319
27320
27321
27322 pattern = Pattern
27323 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27324
27325 assertEquals(2, GrouperUtil.length(outputLines));
27326 outputLine = outputLines[0];
27327
27328 matcher = pattern.matcher(outputLine);
27329
27330 assertTrue(outputLine, matcher.matches());
27331 assertEquals(outputLine, "0", matcher.group(1));
27332 assertEquals(outputLine, "mem_asgn", matcher.group(2));
27333 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27334 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27335 assertEquals(outputLine, "assign", matcher.group(5));
27336 assertEquals(outputLine, "123", matcher.group(6));
27337 assertEquals(outputLine, "T", matcher.group(7));
27338 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27339
27340 outputLine = outputLines[1];
27341
27342 matcher = pattern.matcher(outputLine);
27343
27344 assertTrue(outputLine, matcher.matches());
27345 assertEquals(outputLine, "1", matcher.group(1));
27346 assertEquals(outputLine, "member", matcher.group(2));
27347 assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
27348 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
27349 assertEquals(outputLine, "assign", matcher.group(5));
27350 assertEquals(outputLine, "abc", matcher.group(6));
27351 assertEquals(outputLine, "T", matcher.group(7));
27352 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
27353
27354 assertTrue(GrouperClientWs.mostRecentRequest,
27355 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27356 assertTrue(GrouperClientWs.mostRecentRequest,
27357 !GrouperClientWs.mostRecentRequest.contains("actions"));
27358 assertTrue(GrouperClientWs.mostRecentRequest,
27359 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27360 assertTrue(GrouperClientWs.mostRecentRequest,
27361 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27362 assertTrue(GrouperClientWs.mostRecentRequest,
27363 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27364 assertTrue(GrouperClientWs.mostRecentRequest,
27365 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27366 assertTrue(GrouperClientWs.mostRecentRequest,
27367 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27368 assertTrue(GrouperClientWs.mostRecentRequest,
27369 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27370 assertTrue(GrouperClientWs.mostRecentRequest,
27371 !GrouperClientWs.mostRecentRequest.contains("params"));
27372 assertTrue(GrouperClientWs.mostRecentRequest,
27373 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27374 assertTrue(GrouperClientWs.mostRecentRequest,
27375 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27376 assertTrue(GrouperClientWs.mostRecentRequest,
27377 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27378 assertTrue(GrouperClientWs.mostRecentRequest,
27379 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27380 assertTrue(GrouperClientWs.mostRecentRequest,
27381 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27382 assertTrue(GrouperClientWs.mostRecentRequest,
27383 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27384 assertTrue(GrouperClientWs.mostRecentRequest,
27385 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27386 assertTrue(GrouperClientWs.mostRecentRequest,
27387 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27388 assertTrue(GrouperClientWs.mostRecentRequest,
27389 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27390 assertTrue(GrouperClientWs.mostRecentRequest,
27391 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27392 assertFalse(GrouperClientWs.mostRecentRequest,
27393 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27394 assertFalse(GrouperClientWs.mostRecentRequest,
27395 GrouperClientWs.mostRecentRequest.contains("theValue"));
27396 assertFalse(GrouperClientWs.mostRecentRequest,
27397 GrouperClientWs.mostRecentRequest.contains(">123<"));
27398 assertTrue(GrouperClientWs.mostRecentRequest,
27399 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27400 assertFalse(GrouperClientWs.mostRecentRequest,
27401 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27402 assertTrue(GrouperClientWs.mostRecentRequest,
27403 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27404 assertTrue(GrouperClientWs.mostRecentRequest,
27405 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27406 assertTrue(GrouperClientWs.mostRecentRequest,
27407 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27408 assertTrue(GrouperClientWs.mostRecentRequest,
27409 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27410 assertTrue(GrouperClientWs.mostRecentRequest,
27411 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27412 assertTrue(GrouperClientWs.mostRecentRequest,
27413 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27414
27415
27416
27417
27418
27419 baos = new ByteArrayOutputStream();
27420 System.setOut(new PrintStream(baos));
27421
27422 try {
27423 GrouperClient.main(GrouperClientUtils.splitTrim(
27424 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
27425 ,
27426 " "));
27427
27428 System.out.flush();
27429 output = new String(baos.toByteArray());
27430
27431 System.setOut(systemOut);
27432
27433 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27434
27435
27436
27437 pattern = Pattern
27438 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27439
27440 assertEquals(0, GrouperUtil.length(outputLines));
27441 fail("Shouldnt get here");
27442 } catch (Exception e) {
27443
27444 } finally {
27445 System.setOut(systemOut);
27446
27447 }
27448
27449 assertTrue(GrouperClientWs.mostRecentRequest,
27450 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27451 assertTrue(GrouperClientWs.mostRecentRequest,
27452 !GrouperClientWs.mostRecentRequest.contains("actions"));
27453 assertTrue(GrouperClientWs.mostRecentRequest,
27454 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27455 assertTrue(GrouperClientWs.mostRecentRequest,
27456 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27457 assertTrue(GrouperClientWs.mostRecentRequest,
27458 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27459 assertTrue(GrouperClientWs.mostRecentRequest,
27460 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27461 assertTrue(GrouperClientWs.mostRecentRequest,
27462 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27463 assertTrue(GrouperClientWs.mostRecentRequest,
27464 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27465 assertTrue(GrouperClientWs.mostRecentRequest,
27466 !GrouperClientWs.mostRecentRequest.contains("params"));
27467 assertTrue(GrouperClientWs.mostRecentRequest,
27468 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27469 assertTrue(GrouperClientWs.mostRecentRequest,
27470 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27471 assertFalse(GrouperClientWs.mostRecentRequest,
27472 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27473 assertTrue(GrouperClientWs.mostRecentRequest,
27474 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27475 assertTrue(GrouperClientWs.mostRecentRequest,
27476 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27477 assertTrue(GrouperClientWs.mostRecentRequest,
27478 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27479 assertTrue(GrouperClientWs.mostRecentRequest,
27480 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27481 assertTrue(GrouperClientWs.mostRecentRequest,
27482 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27483 assertTrue(GrouperClientWs.mostRecentRequest,
27484 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27485 assertTrue(GrouperClientWs.mostRecentRequest,
27486 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27487 assertTrue(GrouperClientWs.mostRecentRequest,
27488 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27489 assertFalse(GrouperClientWs.mostRecentRequest,
27490 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27491 assertFalse(GrouperClientWs.mostRecentRequest,
27492 GrouperClientWs.mostRecentRequest.contains("theValue"));
27493 assertFalse(GrouperClientWs.mostRecentRequest,
27494 GrouperClientWs.mostRecentRequest.contains(">123<"));
27495 assertFalse(GrouperClientWs.mostRecentRequest,
27496 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27497 assertFalse(GrouperClientWs.mostRecentRequest,
27498 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27499 assertTrue(GrouperClientWs.mostRecentRequest,
27500 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27501 assertTrue(GrouperClientWs.mostRecentRequest,
27502 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27503 assertTrue(GrouperClientWs.mostRecentRequest,
27504 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27505 assertTrue(GrouperClientWs.mostRecentRequest,
27506 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27507 assertTrue(GrouperClientWs.mostRecentRequest,
27508 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27509 assertTrue(GrouperClientWs.mostRecentRequest,
27510 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27511
27512
27513
27514
27515 baos = new ByteArrayOutputStream();
27516 System.setOut(new PrintStream(baos));
27517
27518 GrouperClient.main(GrouperClientUtils.splitTrim(
27519 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
27520 ,
27521 " "));
27522
27523 System.out.flush();
27524 output = new String(baos.toByteArray());
27525
27526 System.setOut(systemOut);
27527
27528 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27529
27530
27531
27532 pattern = Pattern
27533 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27534
27535 assertEquals(1, GrouperUtil.length(outputLines));
27536
27537 outputLine = outputLines[0];
27538
27539 matcher = pattern.matcher(outputLine);
27540
27541 assertTrue(outputLine, matcher.matches());
27542 assertEquals(outputLine, "0", matcher.group(1));
27543 assertEquals(outputLine, "mem_asgn", matcher.group(2));
27544 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27545 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27546 assertEquals(outputLine, "assign", matcher.group(5));
27547 assertEquals(outputLine, "123", matcher.group(6));
27548 assertEquals(outputLine, "T", matcher.group(7));
27549 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27550
27551 assertTrue(GrouperClientWs.mostRecentRequest,
27552 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27553 assertTrue(GrouperClientWs.mostRecentRequest,
27554 !GrouperClientWs.mostRecentRequest.contains("actions"));
27555 assertTrue(GrouperClientWs.mostRecentRequest,
27556 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27557 assertTrue(GrouperClientWs.mostRecentRequest,
27558 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27559 assertTrue(GrouperClientWs.mostRecentRequest,
27560 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27561 assertTrue(GrouperClientWs.mostRecentRequest,
27562 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27563 assertTrue(GrouperClientWs.mostRecentRequest,
27564 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27565 assertTrue(GrouperClientWs.mostRecentRequest,
27566 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27567 assertTrue(GrouperClientWs.mostRecentRequest,
27568 !GrouperClientWs.mostRecentRequest.contains("params"));
27569 assertTrue(GrouperClientWs.mostRecentRequest,
27570 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27571 assertTrue(GrouperClientWs.mostRecentRequest,
27572 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27573 assertFalse(GrouperClientWs.mostRecentRequest,
27574 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27575 assertTrue(GrouperClientWs.mostRecentRequest,
27576 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27577 assertTrue(GrouperClientWs.mostRecentRequest,
27578 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27579 assertTrue(GrouperClientWs.mostRecentRequest,
27580 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27581 assertTrue(GrouperClientWs.mostRecentRequest,
27582 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27583 assertTrue(GrouperClientWs.mostRecentRequest,
27584 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27585 assertTrue(GrouperClientWs.mostRecentRequest,
27586 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27587 assertTrue(GrouperClientWs.mostRecentRequest,
27588 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27589 assertTrue(GrouperClientWs.mostRecentRequest,
27590 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27591 assertFalse(GrouperClientWs.mostRecentRequest,
27592 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27593 assertFalse(GrouperClientWs.mostRecentRequest,
27594 GrouperClientWs.mostRecentRequest.contains("theValue"));
27595 assertFalse(GrouperClientWs.mostRecentRequest,
27596 GrouperClientWs.mostRecentRequest.contains(">123<"));
27597 assertFalse(GrouperClientWs.mostRecentRequest,
27598 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27599 assertFalse(GrouperClientWs.mostRecentRequest,
27600 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27601 assertTrue(GrouperClientWs.mostRecentRequest,
27602 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27603 assertTrue(GrouperClientWs.mostRecentRequest,
27604 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27605 assertTrue(GrouperClientWs.mostRecentRequest,
27606 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27607 assertTrue(GrouperClientWs.mostRecentRequest,
27608 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27609 assertTrue(GrouperClientWs.mostRecentRequest,
27610 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27611 assertTrue(GrouperClientWs.mostRecentRequest,
27612 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27613
27614
27615
27616
27617
27618 baos = new ByteArrayOutputStream();
27619 System.setOut(new PrintStream(baos));
27620
27621 GrouperClient.main(GrouperClientUtils.splitTrim(
27622 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
27623 ,
27624 " "));
27625
27626 System.out.flush();
27627 output = new String(baos.toByteArray());
27628
27629 System.setOut(systemOut);
27630
27631 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27632
27633
27634
27635 pattern = Pattern
27636 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27637
27638 assertEquals(1, GrouperUtil.length(outputLines));
27639
27640 outputLine = outputLines[0];
27641
27642 matcher = pattern.matcher(outputLine);
27643
27644 assertTrue(outputLine, matcher.matches());
27645 assertEquals(outputLine, "0", matcher.group(1));
27646 assertEquals(outputLine, "mem_asgn", matcher.group(2));
27647 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27648 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27649 assertEquals(outputLine, "assign", matcher.group(5));
27650 assertEquals(outputLine, "123", matcher.group(6));
27651 assertEquals(outputLine, "T", matcher.group(7));
27652 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27653
27654 assertTrue(GrouperClientWs.mostRecentRequest,
27655 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27656 assertTrue(GrouperClientWs.mostRecentRequest,
27657 !GrouperClientWs.mostRecentRequest.contains("actions"));
27658 assertTrue(GrouperClientWs.mostRecentRequest,
27659 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27660 assertTrue(GrouperClientWs.mostRecentRequest,
27661 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27662 assertTrue(GrouperClientWs.mostRecentRequest,
27663 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27664 assertTrue(GrouperClientWs.mostRecentRequest,
27665 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27666 assertTrue(GrouperClientWs.mostRecentRequest,
27667 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27668 assertTrue(GrouperClientWs.mostRecentRequest,
27669 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27670 assertTrue(GrouperClientWs.mostRecentRequest,
27671 !GrouperClientWs.mostRecentRequest.contains("params"));
27672 assertTrue(GrouperClientWs.mostRecentRequest,
27673 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27674 assertTrue(GrouperClientWs.mostRecentRequest,
27675 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27676 assertFalse(GrouperClientWs.mostRecentRequest,
27677 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27678 assertFalse(GrouperClientWs.mostRecentRequest,
27679 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27680 assertTrue(GrouperClientWs.mostRecentRequest,
27681 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27682 assertTrue(GrouperClientWs.mostRecentRequest,
27683 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27684 assertTrue(GrouperClientWs.mostRecentRequest,
27685 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27686 assertTrue(GrouperClientWs.mostRecentRequest,
27687 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27688 assertTrue(GrouperClientWs.mostRecentRequest,
27689 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27690 assertTrue(GrouperClientWs.mostRecentRequest,
27691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27692 assertTrue(GrouperClientWs.mostRecentRequest,
27693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27694 assertFalse(GrouperClientWs.mostRecentRequest,
27695 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27696 assertFalse(GrouperClientWs.mostRecentRequest,
27697 GrouperClientWs.mostRecentRequest.contains("theValue"));
27698 assertFalse(GrouperClientWs.mostRecentRequest,
27699 GrouperClientWs.mostRecentRequest.contains(">123<"));
27700 assertFalse(GrouperClientWs.mostRecentRequest,
27701 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27702 assertFalse(GrouperClientWs.mostRecentRequest,
27703 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27704 assertTrue(GrouperClientWs.mostRecentRequest,
27705 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27706 assertTrue(GrouperClientWs.mostRecentRequest,
27707 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27708 assertTrue(GrouperClientWs.mostRecentRequest,
27709 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27710 assertTrue(GrouperClientWs.mostRecentRequest,
27711 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27712 assertTrue(GrouperClientWs.mostRecentRequest,
27713 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27714 assertTrue(GrouperClientWs.mostRecentRequest,
27715 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27716
27717
27718
27719
27720
27721
27722 baos = new ByteArrayOutputStream();
27723 System.setOut(new PrintStream(baos));
27724
27725 try {
27726 GrouperClient.main(GrouperClientUtils.splitTrim(
27727 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
27728 ,
27729 " "));
27730
27731 System.out.flush();
27732 output = new String(baos.toByteArray());
27733
27734 System.setOut(systemOut);
27735
27736 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27737
27738
27739
27740 pattern = Pattern
27741 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27742
27743 assertEquals(0, GrouperUtil.length(outputLines));
27744
27745 fail("shouldnt get here");
27746 } catch (Exception e) {
27747
27748 } finally {
27749 System.setOut(systemOut);
27750 }
27751
27752 assertTrue(GrouperClientWs.mostRecentRequest,
27753 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27754 assertTrue(GrouperClientWs.mostRecentRequest,
27755 !GrouperClientWs.mostRecentRequest.contains("actions"));
27756 assertTrue(GrouperClientWs.mostRecentRequest,
27757 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27758 assertTrue(GrouperClientWs.mostRecentRequest,
27759 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27760 assertTrue(GrouperClientWs.mostRecentRequest,
27761 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27762 assertTrue(GrouperClientWs.mostRecentRequest,
27763 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27764 assertTrue(GrouperClientWs.mostRecentRequest,
27765 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27766 assertTrue(GrouperClientWs.mostRecentRequest,
27767 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27768 assertTrue(GrouperClientWs.mostRecentRequest,
27769 !GrouperClientWs.mostRecentRequest.contains("params"));
27770 assertTrue(GrouperClientWs.mostRecentRequest,
27771 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27772 assertTrue(GrouperClientWs.mostRecentRequest,
27773 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27774 assertFalse(GrouperClientWs.mostRecentRequest,
27775 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27776 assertFalse(GrouperClientWs.mostRecentRequest,
27777 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27778 assertTrue(GrouperClientWs.mostRecentRequest,
27779 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27780 assertTrue(GrouperClientWs.mostRecentRequest,
27781 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27782 assertTrue(GrouperClientWs.mostRecentRequest,
27783 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27784 assertTrue(GrouperClientWs.mostRecentRequest,
27785 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27786 assertTrue(GrouperClientWs.mostRecentRequest,
27787 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27788 assertTrue(GrouperClientWs.mostRecentRequest,
27789 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27790 assertTrue(GrouperClientWs.mostRecentRequest,
27791 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27792 assertFalse(GrouperClientWs.mostRecentRequest,
27793 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27794 assertFalse(GrouperClientWs.mostRecentRequest,
27795 GrouperClientWs.mostRecentRequest.contains("theValue"));
27796 assertFalse(GrouperClientWs.mostRecentRequest,
27797 GrouperClientWs.mostRecentRequest.contains(">123<"));
27798 assertFalse(GrouperClientWs.mostRecentRequest,
27799 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27800 assertFalse(GrouperClientWs.mostRecentRequest,
27801 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27802 assertTrue(GrouperClientWs.mostRecentRequest,
27803 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27804 assertTrue(GrouperClientWs.mostRecentRequest,
27805 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27806 assertTrue(GrouperClientWs.mostRecentRequest,
27807 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27808 assertTrue(GrouperClientWs.mostRecentRequest,
27809 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27810 assertTrue(GrouperClientWs.mostRecentRequest,
27811 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27812 assertTrue(GrouperClientWs.mostRecentRequest,
27813 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27814
27815
27816
27817
27818
27819 baos = new ByteArrayOutputStream();
27820 System.setOut(new PrintStream(baos));
27821
27822 GrouperClient.main(GrouperClientUtils.splitTrim(
27823 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
27824 ,
27825 " "));
27826
27827 System.out.flush();
27828 output = new String(baos.toByteArray());
27829
27830 System.setOut(systemOut);
27831
27832 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27833
27834
27835
27836 pattern = Pattern
27837 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27838
27839 assertEquals(1, GrouperUtil.length(outputLines));
27840
27841 outputLine = outputLines[0];
27842
27843 matcher = pattern.matcher(outputLine);
27844
27845 assertTrue(outputLine, matcher.matches());
27846 assertEquals(outputLine, "0", matcher.group(1));
27847 assertEquals(outputLine, "mem_asgn", matcher.group(2));
27848 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27849 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27850 assertEquals(outputLine, "assign", matcher.group(5));
27851 assertEquals(outputLine, "123", matcher.group(6));
27852 assertEquals(outputLine, "T", matcher.group(7));
27853 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27854
27855 assertTrue(GrouperClientWs.mostRecentRequest,
27856 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27857 assertTrue(GrouperClientWs.mostRecentRequest,
27858 !GrouperClientWs.mostRecentRequest.contains("actions"));
27859 assertTrue(GrouperClientWs.mostRecentRequest,
27860 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27861 assertTrue(GrouperClientWs.mostRecentRequest,
27862 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27863 assertTrue(GrouperClientWs.mostRecentRequest,
27864 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27865 assertTrue(GrouperClientWs.mostRecentRequest,
27866 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27867 assertTrue(GrouperClientWs.mostRecentRequest,
27868 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27869 assertTrue(GrouperClientWs.mostRecentRequest,
27870 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27871 assertTrue(GrouperClientWs.mostRecentRequest,
27872 !GrouperClientWs.mostRecentRequest.contains("params"));
27873 assertTrue(GrouperClientWs.mostRecentRequest,
27874 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27875 assertTrue(GrouperClientWs.mostRecentRequest,
27876 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27877 assertFalse(GrouperClientWs.mostRecentRequest,
27878 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27879 assertTrue(GrouperClientWs.mostRecentRequest,
27880 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27881 assertTrue(GrouperClientWs.mostRecentRequest,
27882 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27883 assertTrue(GrouperClientWs.mostRecentRequest,
27884 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27885 assertTrue(GrouperClientWs.mostRecentRequest,
27886 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27887 assertTrue(GrouperClientWs.mostRecentRequest,
27888 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27889 assertTrue(GrouperClientWs.mostRecentRequest,
27890 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27891 assertTrue(GrouperClientWs.mostRecentRequest,
27892 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27893 assertTrue(GrouperClientWs.mostRecentRequest,
27894 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27895 assertFalse(GrouperClientWs.mostRecentRequest,
27896 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27897 assertFalse(GrouperClientWs.mostRecentRequest,
27898 GrouperClientWs.mostRecentRequest.contains("theValue"));
27899 assertFalse(GrouperClientWs.mostRecentRequest,
27900 GrouperClientWs.mostRecentRequest.contains(">123<"));
27901 assertFalse(GrouperClientWs.mostRecentRequest,
27902 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27903 assertFalse(GrouperClientWs.mostRecentRequest,
27904 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27905 assertTrue(GrouperClientWs.mostRecentRequest,
27906 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27907 assertTrue(GrouperClientWs.mostRecentRequest,
27908 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27909 assertTrue(GrouperClientWs.mostRecentRequest,
27910 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27911 assertTrue(GrouperClientWs.mostRecentRequest,
27912 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27913 assertTrue(GrouperClientWs.mostRecentRequest,
27914 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27915 assertTrue(GrouperClientWs.mostRecentRequest,
27916 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27917
27918
27919
27920
27921
27922 baos = new ByteArrayOutputStream();
27923 System.setOut(new PrintStream(baos));
27924
27925 GrouperClient.main(GrouperClientUtils.splitTrim(
27926 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
27927 ,
27928 " "));
27929
27930 System.out.flush();
27931 output = new String(baos.toByteArray());
27932
27933 System.setOut(systemOut);
27934
27935 outputLines = GrouperClientUtils.splitTrim(output, "\n");
27936
27937
27938
27939 pattern = Pattern
27940 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27941
27942 assertEquals(1, GrouperUtil.length(outputLines));
27943
27944 outputLine = outputLines[0];
27945
27946 matcher = pattern.matcher(outputLine);
27947
27948 assertTrue(outputLine, matcher.matches());
27949 assertEquals(outputLine, "0", matcher.group(1));
27950 assertEquals(outputLine, "mem_asgn", matcher.group(2));
27951 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27952 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27953 assertEquals(outputLine, "assign", matcher.group(5));
27954 assertEquals(outputLine, "123", matcher.group(6));
27955 assertEquals(outputLine, "T", matcher.group(7));
27956 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27957
27958 assertTrue(GrouperClientWs.mostRecentRequest,
27959 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27960 assertTrue(GrouperClientWs.mostRecentRequest,
27961 !GrouperClientWs.mostRecentRequest.contains("actions"));
27962 assertTrue(GrouperClientWs.mostRecentRequest,
27963 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27964 assertTrue(GrouperClientWs.mostRecentRequest,
27965 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27966 assertTrue(GrouperClientWs.mostRecentRequest,
27967 !GrouperClientWs.mostRecentRequest.contains("enabled"));
27968 assertTrue(GrouperClientWs.mostRecentRequest,
27969 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27970 assertTrue(GrouperClientWs.mostRecentRequest,
27971 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27972 assertTrue(GrouperClientWs.mostRecentRequest,
27973 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27974 assertTrue(GrouperClientWs.mostRecentRequest,
27975 !GrouperClientWs.mostRecentRequest.contains("params"));
27976 assertTrue(GrouperClientWs.mostRecentRequest,
27977 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27978 assertTrue(GrouperClientWs.mostRecentRequest,
27979 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27980 assertFalse(GrouperClientWs.mostRecentRequest,
27981 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27982 assertTrue(GrouperClientWs.mostRecentRequest,
27983 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27984 assertTrue(GrouperClientWs.mostRecentRequest,
27985 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27986 assertTrue(GrouperClientWs.mostRecentRequest,
27987 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27988 assertTrue(GrouperClientWs.mostRecentRequest,
27989 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27990 assertTrue(GrouperClientWs.mostRecentRequest,
27991 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27992 assertTrue(GrouperClientWs.mostRecentRequest,
27993 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27994 assertTrue(GrouperClientWs.mostRecentRequest,
27995 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27996 assertTrue(GrouperClientWs.mostRecentRequest,
27997 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27998 assertFalse(GrouperClientWs.mostRecentRequest,
27999 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28000 assertFalse(GrouperClientWs.mostRecentRequest,
28001 GrouperClientWs.mostRecentRequest.contains("theValue"));
28002 assertFalse(GrouperClientWs.mostRecentRequest,
28003 GrouperClientWs.mostRecentRequest.contains(">123<"));
28004 assertFalse(GrouperClientWs.mostRecentRequest,
28005 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28006 assertFalse(GrouperClientWs.mostRecentRequest,
28007 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28008 assertTrue(GrouperClientWs.mostRecentRequest,
28009 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28010 assertTrue(GrouperClientWs.mostRecentRequest,
28011 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28012 assertTrue(GrouperClientWs.mostRecentRequest,
28013 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
28014 assertTrue(GrouperClientWs.mostRecentRequest,
28015 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28016 assertTrue(GrouperClientWs.mostRecentRequest,
28017 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
28018 assertTrue(GrouperClientWs.mostRecentRequest,
28019 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28020
28021
28022
28023
28024
28025
28026 baos = new ByteArrayOutputStream();
28027 System.setOut(new PrintStream(baos));
28028
28029 try {
28030 GrouperClient.main(GrouperClientUtils.splitTrim(
28031 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
28032 ,
28033 " "));
28034
28035 System.out.flush();
28036 output = new String(baos.toByteArray());
28037
28038 System.setOut(systemOut);
28039
28040 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28041
28042
28043
28044 pattern = Pattern
28045 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28046
28047 assertEquals(0, GrouperUtil.length(outputLines));
28048 fail("Shouldnt get here");
28049 } catch (Exception e) {
28050
28051 } finally {
28052
28053 System.setOut(systemOut);
28054
28055 }
28056
28057 assertTrue(GrouperClientWs.mostRecentRequest,
28058 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28059 assertTrue(GrouperClientWs.mostRecentRequest,
28060 !GrouperClientWs.mostRecentRequest.contains("actions"));
28061 assertTrue(GrouperClientWs.mostRecentRequest,
28062 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28063 assertTrue(GrouperClientWs.mostRecentRequest,
28064 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28065 assertTrue(GrouperClientWs.mostRecentRequest,
28066 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28067 assertTrue(GrouperClientWs.mostRecentRequest,
28068 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28069 assertTrue(GrouperClientWs.mostRecentRequest,
28070 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28071 assertTrue(GrouperClientWs.mostRecentRequest,
28072 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28073 assertTrue(GrouperClientWs.mostRecentRequest,
28074 !GrouperClientWs.mostRecentRequest.contains("params"));
28075 assertTrue(GrouperClientWs.mostRecentRequest,
28076 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28077 assertTrue(GrouperClientWs.mostRecentRequest,
28078 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28079 assertFalse(GrouperClientWs.mostRecentRequest,
28080 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28081 assertTrue(GrouperClientWs.mostRecentRequest,
28082 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28083 assertTrue(GrouperClientWs.mostRecentRequest,
28084 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28085 assertTrue(GrouperClientWs.mostRecentRequest,
28086 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28087 assertTrue(GrouperClientWs.mostRecentRequest,
28088 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28089 assertTrue(GrouperClientWs.mostRecentRequest,
28090 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28091 assertTrue(GrouperClientWs.mostRecentRequest,
28092 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28093 assertTrue(GrouperClientWs.mostRecentRequest,
28094 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28095 assertTrue(GrouperClientWs.mostRecentRequest,
28096 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28097 assertFalse(GrouperClientWs.mostRecentRequest,
28098 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28099 assertFalse(GrouperClientWs.mostRecentRequest,
28100 GrouperClientWs.mostRecentRequest.contains("theValue"));
28101 assertFalse(GrouperClientWs.mostRecentRequest,
28102 GrouperClientWs.mostRecentRequest.contains(">123<"));
28103 assertFalse(GrouperClientWs.mostRecentRequest,
28104 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28105 assertFalse(GrouperClientWs.mostRecentRequest,
28106 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28107 assertTrue(GrouperClientWs.mostRecentRequest,
28108 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28109 assertTrue(GrouperClientWs.mostRecentRequest,
28110 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28111 assertTrue(GrouperClientWs.mostRecentRequest,
28112 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
28113 assertTrue(GrouperClientWs.mostRecentRequest,
28114 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28115 assertTrue(GrouperClientWs.mostRecentRequest,
28116 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
28117 assertTrue(GrouperClientWs.mostRecentRequest,
28118 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28119
28120
28121
28122
28123
28124 baos = new ByteArrayOutputStream();
28125 System.setOut(new PrintStream(baos));
28126
28127 GrouperClient.main(GrouperClientUtils.splitTrim(
28128 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
28129 ,
28130 " "));
28131
28132 System.out.flush();
28133 output = new String(baos.toByteArray());
28134
28135 System.setOut(systemOut);
28136
28137 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28138
28139
28140
28141 pattern = Pattern
28142 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28143
28144 assertEquals(1, GrouperUtil.length(outputLines));
28145
28146 outputLine = outputLines[0];
28147
28148 matcher = pattern.matcher(outputLine);
28149
28150 assertTrue(outputLine, matcher.matches());
28151 assertEquals(outputLine, "0", matcher.group(1));
28152 assertEquals(outputLine, "mem_asgn", matcher.group(2));
28153 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28154 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28155 assertEquals(outputLine, "assign", matcher.group(5));
28156 assertEquals(outputLine, "123", matcher.group(6));
28157 assertEquals(outputLine, "T", matcher.group(7));
28158 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28159
28160 assertTrue(GrouperClientWs.mostRecentRequest,
28161 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28162 assertTrue(GrouperClientWs.mostRecentRequest,
28163 !GrouperClientWs.mostRecentRequest.contains("actions"));
28164 assertTrue(GrouperClientWs.mostRecentRequest,
28165 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28166 assertTrue(GrouperClientWs.mostRecentRequest,
28167 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28168 assertTrue(GrouperClientWs.mostRecentRequest,
28169 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28170 assertTrue(GrouperClientWs.mostRecentRequest,
28171 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28172 assertTrue(GrouperClientWs.mostRecentRequest,
28173 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28174 assertTrue(GrouperClientWs.mostRecentRequest,
28175 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28176 assertTrue(GrouperClientWs.mostRecentRequest,
28177 !GrouperClientWs.mostRecentRequest.contains("params"));
28178 assertTrue(GrouperClientWs.mostRecentRequest,
28179 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28180 assertTrue(GrouperClientWs.mostRecentRequest,
28181 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28182 assertFalse(GrouperClientWs.mostRecentRequest,
28183 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28184 assertFalse(GrouperClientWs.mostRecentRequest,
28185 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28186 assertTrue(GrouperClientWs.mostRecentRequest,
28187 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28188 assertTrue(GrouperClientWs.mostRecentRequest,
28189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28190 assertTrue(GrouperClientWs.mostRecentRequest,
28191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28192 assertTrue(GrouperClientWs.mostRecentRequest,
28193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28194 assertTrue(GrouperClientWs.mostRecentRequest,
28195 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28196 assertTrue(GrouperClientWs.mostRecentRequest,
28197 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28198 assertTrue(GrouperClientWs.mostRecentRequest,
28199 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28200 assertFalse(GrouperClientWs.mostRecentRequest,
28201 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28202 assertFalse(GrouperClientWs.mostRecentRequest,
28203 GrouperClientWs.mostRecentRequest.contains("theValue"));
28204 assertFalse(GrouperClientWs.mostRecentRequest,
28205 GrouperClientWs.mostRecentRequest.contains(">123<"));
28206 assertFalse(GrouperClientWs.mostRecentRequest,
28207 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28208 assertFalse(GrouperClientWs.mostRecentRequest,
28209 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28210 assertTrue(GrouperClientWs.mostRecentRequest,
28211 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28212 assertTrue(GrouperClientWs.mostRecentRequest,
28213 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28214 assertTrue(GrouperClientWs.mostRecentRequest,
28215 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28216 assertTrue(GrouperClientWs.mostRecentRequest,
28217 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28218
28219
28220
28221
28222
28223
28224 baos = new ByteArrayOutputStream();
28225 System.setOut(new PrintStream(baos));
28226
28227 try {
28228 GrouperClient.main(GrouperClientUtils.splitTrim(
28229 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
28230 ,
28231 " "));
28232
28233 System.out.flush();
28234 output = new String(baos.toByteArray());
28235
28236 System.setOut(systemOut);
28237
28238 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28239
28240
28241
28242 pattern = Pattern
28243 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28244
28245 assertEquals(0, GrouperUtil.length(outputLines));
28246 fail("Shouldnt get here");
28247
28248 } catch (Exception e) {
28249
28250 } finally {
28251
28252 System.setOut(systemOut);
28253
28254 }
28255
28256 assertTrue(GrouperClientWs.mostRecentRequest,
28257 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28258 assertTrue(GrouperClientWs.mostRecentRequest,
28259 !GrouperClientWs.mostRecentRequest.contains("actions"));
28260 assertTrue(GrouperClientWs.mostRecentRequest,
28261 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28262 assertTrue(GrouperClientWs.mostRecentRequest,
28263 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28264 assertTrue(GrouperClientWs.mostRecentRequest,
28265 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28266 assertTrue(GrouperClientWs.mostRecentRequest,
28267 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28268 assertTrue(GrouperClientWs.mostRecentRequest,
28269 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28270 assertTrue(GrouperClientWs.mostRecentRequest,
28271 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28272 assertTrue(GrouperClientWs.mostRecentRequest,
28273 !GrouperClientWs.mostRecentRequest.contains("params"));
28274 assertTrue(GrouperClientWs.mostRecentRequest,
28275 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28276 assertTrue(GrouperClientWs.mostRecentRequest,
28277 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28278 assertFalse(GrouperClientWs.mostRecentRequest,
28279 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28280 assertFalse(GrouperClientWs.mostRecentRequest,
28281 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28282 assertTrue(GrouperClientWs.mostRecentRequest,
28283 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28284 assertTrue(GrouperClientWs.mostRecentRequest,
28285 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28286 assertTrue(GrouperClientWs.mostRecentRequest,
28287 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28288 assertTrue(GrouperClientWs.mostRecentRequest,
28289 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28290 assertTrue(GrouperClientWs.mostRecentRequest,
28291 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28292 assertTrue(GrouperClientWs.mostRecentRequest,
28293 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28294 assertTrue(GrouperClientWs.mostRecentRequest,
28295 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28296 assertFalse(GrouperClientWs.mostRecentRequest,
28297 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28298 assertFalse(GrouperClientWs.mostRecentRequest,
28299 GrouperClientWs.mostRecentRequest.contains("theValue"));
28300 assertFalse(GrouperClientWs.mostRecentRequest,
28301 GrouperClientWs.mostRecentRequest.contains(">123<"));
28302 assertFalse(GrouperClientWs.mostRecentRequest,
28303 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28304 assertFalse(GrouperClientWs.mostRecentRequest,
28305 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28306 assertTrue(GrouperClientWs.mostRecentRequest,
28307 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28308 assertTrue(GrouperClientWs.mostRecentRequest,
28309 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28310 assertTrue(GrouperClientWs.mostRecentRequest,
28311 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28312 assertTrue(GrouperClientWs.mostRecentRequest,
28313 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28314
28315
28316
28317
28318
28319 baos = new ByteArrayOutputStream();
28320 System.setOut(new PrintStream(baos));
28321
28322 GrouperClient.main(GrouperClientUtils.splitTrim(
28323 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
28324 ,
28325 " "));
28326
28327 System.out.flush();
28328 output = new String(baos.toByteArray());
28329
28330 System.setOut(systemOut);
28331
28332 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28333
28334
28335
28336 pattern = Pattern
28337 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28338
28339 assertEquals(1, GrouperUtil.length(outputLines));
28340
28341 outputLine = outputLines[0];
28342
28343 matcher = pattern.matcher(outputLine);
28344
28345 assertTrue(outputLine, matcher.matches());
28346 assertEquals(outputLine, "0", matcher.group(1));
28347 assertEquals(outputLine, "mem_asgn", matcher.group(2));
28348 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28349 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28350 assertEquals(outputLine, "assign", matcher.group(5));
28351 assertEquals(outputLine, "123", matcher.group(6));
28352 assertEquals(outputLine, "T", matcher.group(7));
28353 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28354
28355 assertTrue(GrouperClientWs.mostRecentRequest,
28356 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28357 assertTrue(GrouperClientWs.mostRecentRequest,
28358 !GrouperClientWs.mostRecentRequest.contains("actions"));
28359 assertTrue(GrouperClientWs.mostRecentRequest,
28360 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28361 assertTrue(GrouperClientWs.mostRecentRequest,
28362 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28363 assertTrue(GrouperClientWs.mostRecentRequest,
28364 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28365 assertTrue(GrouperClientWs.mostRecentRequest,
28366 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28367 assertTrue(GrouperClientWs.mostRecentRequest,
28368 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28369 assertTrue(GrouperClientWs.mostRecentRequest,
28370 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28371 assertTrue(GrouperClientWs.mostRecentRequest,
28372 !GrouperClientWs.mostRecentRequest.contains("params"));
28373 assertTrue(GrouperClientWs.mostRecentRequest,
28374 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28375 assertTrue(GrouperClientWs.mostRecentRequest,
28376 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28377 assertFalse(GrouperClientWs.mostRecentRequest,
28378 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28379 assertTrue(GrouperClientWs.mostRecentRequest,
28380 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28381 assertTrue(GrouperClientWs.mostRecentRequest,
28382 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28383 assertTrue(GrouperClientWs.mostRecentRequest,
28384 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28385 assertTrue(GrouperClientWs.mostRecentRequest,
28386 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28387 assertTrue(GrouperClientWs.mostRecentRequest,
28388 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28389 assertTrue(GrouperClientWs.mostRecentRequest,
28390 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28391 assertTrue(GrouperClientWs.mostRecentRequest,
28392 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28393 assertTrue(GrouperClientWs.mostRecentRequest,
28394 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28395 assertFalse(GrouperClientWs.mostRecentRequest,
28396 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28397 assertFalse(GrouperClientWs.mostRecentRequest,
28398 GrouperClientWs.mostRecentRequest.contains("theValue"));
28399 assertFalse(GrouperClientWs.mostRecentRequest,
28400 GrouperClientWs.mostRecentRequest.contains(">123<"));
28401 assertFalse(GrouperClientWs.mostRecentRequest,
28402 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28403 assertFalse(GrouperClientWs.mostRecentRequest,
28404 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28405 assertTrue(GrouperClientWs.mostRecentRequest,
28406 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28407 assertTrue(GrouperClientWs.mostRecentRequest,
28408 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28409 assertTrue(GrouperClientWs.mostRecentRequest,
28410 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28411 assertTrue(GrouperClientWs.mostRecentRequest,
28412 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28413
28414
28415
28416
28417
28418
28419 baos = new ByteArrayOutputStream();
28420 System.setOut(new PrintStream(baos));
28421
28422 try {
28423 GrouperClient.main(GrouperClientUtils.splitTrim(
28424 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
28425 ,
28426 " "));
28427
28428 System.out.flush();
28429 output = new String(baos.toByteArray());
28430
28431 System.setOut(systemOut);
28432
28433 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28434
28435
28436
28437 pattern = Pattern
28438 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28439
28440 assertEquals(1, GrouperUtil.length(outputLines));
28441 fail("Shouldnt get here");
28442 } catch (Exception e) {
28443
28444 } finally {
28445
28446 System.setOut(systemOut);
28447
28448 }
28449
28450 assertTrue(GrouperClientWs.mostRecentRequest,
28451 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28452 assertTrue(GrouperClientWs.mostRecentRequest,
28453 !GrouperClientWs.mostRecentRequest.contains("actions"));
28454 assertTrue(GrouperClientWs.mostRecentRequest,
28455 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28456 assertTrue(GrouperClientWs.mostRecentRequest,
28457 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28458 assertTrue(GrouperClientWs.mostRecentRequest,
28459 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28460 assertTrue(GrouperClientWs.mostRecentRequest,
28461 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28462 assertTrue(GrouperClientWs.mostRecentRequest,
28463 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28464 assertTrue(GrouperClientWs.mostRecentRequest,
28465 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28466 assertTrue(GrouperClientWs.mostRecentRequest,
28467 !GrouperClientWs.mostRecentRequest.contains("params"));
28468 assertTrue(GrouperClientWs.mostRecentRequest,
28469 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28470 assertTrue(GrouperClientWs.mostRecentRequest,
28471 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28472 assertFalse(GrouperClientWs.mostRecentRequest,
28473 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28474 assertTrue(GrouperClientWs.mostRecentRequest,
28475 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28476 assertTrue(GrouperClientWs.mostRecentRequest,
28477 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28478 assertTrue(GrouperClientWs.mostRecentRequest,
28479 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28480 assertTrue(GrouperClientWs.mostRecentRequest,
28481 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28482 assertTrue(GrouperClientWs.mostRecentRequest,
28483 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28484 assertTrue(GrouperClientWs.mostRecentRequest,
28485 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28486 assertTrue(GrouperClientWs.mostRecentRequest,
28487 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28488 assertTrue(GrouperClientWs.mostRecentRequest,
28489 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28490 assertFalse(GrouperClientWs.mostRecentRequest,
28491 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28492 assertFalse(GrouperClientWs.mostRecentRequest,
28493 GrouperClientWs.mostRecentRequest.contains("theValue"));
28494 assertFalse(GrouperClientWs.mostRecentRequest,
28495 GrouperClientWs.mostRecentRequest.contains(">123<"));
28496 assertFalse(GrouperClientWs.mostRecentRequest,
28497 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28498 assertFalse(GrouperClientWs.mostRecentRequest,
28499 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28500 assertTrue(GrouperClientWs.mostRecentRequest,
28501 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28502 assertTrue(GrouperClientWs.mostRecentRequest,
28503 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28504 assertTrue(GrouperClientWs.mostRecentRequest,
28505 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28506 assertTrue(GrouperClientWs.mostRecentRequest,
28507 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28508
28509
28510
28511
28512
28513 baos = new ByteArrayOutputStream();
28514 System.setOut(new PrintStream(baos));
28515
28516 GrouperClient.main(GrouperClientUtils.splitTrim(
28517 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
28518 + " --assignAssignOwnerActions=assign",
28519 " "));
28520
28521 System.out.flush();
28522 output = new String(baos.toByteArray());
28523
28524 System.setOut(systemOut);
28525
28526 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28527
28528
28529
28530 pattern = Pattern
28531 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28532
28533 assertEquals(1, GrouperUtil.length(outputLines));
28534
28535 outputLine = outputLines[0];
28536
28537 matcher = pattern.matcher(outputLine);
28538
28539 assertTrue(outputLine, matcher.matches());
28540 assertEquals(outputLine, "0", matcher.group(1));
28541 assertEquals(outputLine, "mem_asgn", matcher.group(2));
28542 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28543 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28544 assertEquals(outputLine, "assign", matcher.group(5));
28545 assertEquals(outputLine, "123", matcher.group(6));
28546 assertEquals(outputLine, "T", matcher.group(7));
28547 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28548
28549 assertTrue(GrouperClientWs.mostRecentRequest,
28550 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28551 assertTrue(GrouperClientWs.mostRecentRequest,
28552 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
28553 assertTrue(GrouperClientWs.mostRecentRequest,
28554 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28555 assertTrue(GrouperClientWs.mostRecentRequest,
28556 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28557 assertTrue(GrouperClientWs.mostRecentRequest,
28558 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28559 assertTrue(GrouperClientWs.mostRecentRequest,
28560 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28561 assertTrue(GrouperClientWs.mostRecentRequest,
28562 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28563 assertTrue(GrouperClientWs.mostRecentRequest,
28564 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28565 assertTrue(GrouperClientWs.mostRecentRequest,
28566 !GrouperClientWs.mostRecentRequest.contains("params"));
28567 assertTrue(GrouperClientWs.mostRecentRequest,
28568 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28569 assertTrue(GrouperClientWs.mostRecentRequest,
28570 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28571 assertFalse(GrouperClientWs.mostRecentRequest,
28572 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28573 assertTrue(GrouperClientWs.mostRecentRequest,
28574 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28575 assertTrue(GrouperClientWs.mostRecentRequest,
28576 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28577 assertTrue(GrouperClientWs.mostRecentRequest,
28578 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28579 assertTrue(GrouperClientWs.mostRecentRequest,
28580 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28581 assertTrue(GrouperClientWs.mostRecentRequest,
28582 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28583 assertTrue(GrouperClientWs.mostRecentRequest,
28584 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28585 assertTrue(GrouperClientWs.mostRecentRequest,
28586 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28587 assertTrue(GrouperClientWs.mostRecentRequest,
28588 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28589 assertFalse(GrouperClientWs.mostRecentRequest,
28590 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28591 assertFalse(GrouperClientWs.mostRecentRequest,
28592 GrouperClientWs.mostRecentRequest.contains("theValue"));
28593 assertFalse(GrouperClientWs.mostRecentRequest,
28594 GrouperClientWs.mostRecentRequest.contains(">123<"));
28595 assertFalse(GrouperClientWs.mostRecentRequest,
28596 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28597 assertFalse(GrouperClientWs.mostRecentRequest,
28598 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28599 assertTrue(GrouperClientWs.mostRecentRequest,
28600 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28601 assertTrue(GrouperClientWs.mostRecentRequest,
28602 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28603 assertTrue(GrouperClientWs.mostRecentRequest,
28604 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28605 assertTrue(GrouperClientWs.mostRecentRequest,
28606 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
28607
28608
28609
28610
28611
28612 baos = new ByteArrayOutputStream();
28613 System.setOut(new PrintStream(baos));
28614
28615 GrouperClient.main(GrouperClientUtils.splitTrim(
28616 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
28617 + " --assignAssignOwnerActions=assign2",
28618 " "));
28619
28620 System.out.flush();
28621 output = new String(baos.toByteArray());
28622
28623 System.setOut(systemOut);
28624
28625 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28626
28627
28628
28629 pattern = Pattern
28630 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28631
28632 assertEquals(0, GrouperUtil.length(outputLines));
28633
28634 assertTrue(GrouperClientWs.mostRecentRequest,
28635 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28636 assertTrue(GrouperClientWs.mostRecentRequest,
28637 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
28638 assertTrue(GrouperClientWs.mostRecentRequest,
28639 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28640 assertTrue(GrouperClientWs.mostRecentRequest,
28641 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28642 assertTrue(GrouperClientWs.mostRecentRequest,
28643 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28644 assertTrue(GrouperClientWs.mostRecentRequest,
28645 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28646 assertTrue(GrouperClientWs.mostRecentRequest,
28647 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28648 assertTrue(GrouperClientWs.mostRecentRequest,
28649 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28650 assertTrue(GrouperClientWs.mostRecentRequest,
28651 !GrouperClientWs.mostRecentRequest.contains("params"));
28652 assertTrue(GrouperClientWs.mostRecentRequest,
28653 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28654 assertTrue(GrouperClientWs.mostRecentRequest,
28655 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28656 assertFalse(GrouperClientWs.mostRecentRequest,
28657 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28658 assertTrue(GrouperClientWs.mostRecentRequest,
28659 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28660 assertTrue(GrouperClientWs.mostRecentRequest,
28661 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28662 assertTrue(GrouperClientWs.mostRecentRequest,
28663 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28664 assertTrue(GrouperClientWs.mostRecentRequest,
28665 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28666 assertTrue(GrouperClientWs.mostRecentRequest,
28667 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28668 assertTrue(GrouperClientWs.mostRecentRequest,
28669 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28670 assertTrue(GrouperClientWs.mostRecentRequest,
28671 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28672 assertTrue(GrouperClientWs.mostRecentRequest,
28673 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28674 assertFalse(GrouperClientWs.mostRecentRequest,
28675 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28676 assertFalse(GrouperClientWs.mostRecentRequest,
28677 GrouperClientWs.mostRecentRequest.contains("theValue"));
28678 assertFalse(GrouperClientWs.mostRecentRequest,
28679 GrouperClientWs.mostRecentRequest.contains(">123<"));
28680 assertFalse(GrouperClientWs.mostRecentRequest,
28681 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28682 assertFalse(GrouperClientWs.mostRecentRequest,
28683 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28684 assertTrue(GrouperClientWs.mostRecentRequest,
28685 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28686 assertTrue(GrouperClientWs.mostRecentRequest,
28687 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28688 assertTrue(GrouperClientWs.mostRecentRequest,
28689 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28690 assertTrue(GrouperClientWs.mostRecentRequest,
28691 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
28692
28693
28694
28695
28696
28697
28698 baos = new ByteArrayOutputStream();
28699 System.setOut(new PrintStream(baos));
28700
28701 GrouperClient.main(GrouperClientUtils.splitTrim(
28702 "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --owner0SubjectId=" + SubjectTestHelper.SUBJ0_ID
28703 ,
28704 " "));
28705
28706 System.out.flush();
28707 output = new String(baos.toByteArray());
28708
28709 System.setOut(systemOut);
28710
28711 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28712
28713
28714
28715 pattern = Pattern
28716 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28717
28718 assertEquals(1, GrouperUtil.length(outputLines));
28719
28720 outputLine = outputLines[0];
28721
28722 matcher = pattern.matcher(outputLine);
28723
28724 assertTrue(outputLine, matcher.matches());
28725 assertEquals(outputLine, "0", matcher.group(1));
28726 assertEquals(outputLine, "mem_asgn", matcher.group(2));
28727 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28728 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28729 assertEquals(outputLine, "assign", matcher.group(5));
28730 assertEquals(outputLine, "123", matcher.group(6));
28731 assertEquals(outputLine, "T", matcher.group(7));
28732 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28733
28734 assertTrue(GrouperClientWs.mostRecentRequest,
28735 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28736 assertTrue(GrouperClientWs.mostRecentRequest,
28737 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
28738 assertTrue(GrouperClientWs.mostRecentRequest,
28739 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28740 assertTrue(GrouperClientWs.mostRecentRequest,
28741 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28742 assertTrue(GrouperClientWs.mostRecentRequest,
28743 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28744 assertTrue(GrouperClientWs.mostRecentRequest,
28745 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28746 assertTrue(GrouperClientWs.mostRecentRequest,
28747 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28748 assertTrue(GrouperClientWs.mostRecentRequest,
28749 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28750 assertTrue(GrouperClientWs.mostRecentRequest,
28751 !GrouperClientWs.mostRecentRequest.contains("params"));
28752 assertTrue(GrouperClientWs.mostRecentRequest,
28753 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28754 assertTrue(GrouperClientWs.mostRecentRequest,
28755 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28756 assertFalse(GrouperClientWs.mostRecentRequest,
28757 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28758 assertFalse(GrouperClientWs.mostRecentRequest,
28759 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28760 assertTrue(GrouperClientWs.mostRecentRequest,
28761 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28762 assertTrue(GrouperClientWs.mostRecentRequest,
28763 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28764 assertTrue(GrouperClientWs.mostRecentRequest,
28765 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28766 assertTrue(GrouperClientWs.mostRecentRequest,
28767 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28768 assertTrue(GrouperClientWs.mostRecentRequest,
28769 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28770 assertTrue(GrouperClientWs.mostRecentRequest,
28771 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28772 assertTrue(GrouperClientWs.mostRecentRequest,
28773 GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28774 assertFalse(GrouperClientWs.mostRecentRequest,
28775 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28776 assertFalse(GrouperClientWs.mostRecentRequest,
28777 GrouperClientWs.mostRecentRequest.contains("theValue"));
28778 assertFalse(GrouperClientWs.mostRecentRequest,
28779 GrouperClientWs.mostRecentRequest.contains(">123<"));
28780 assertFalse(GrouperClientWs.mostRecentRequest,
28781 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28782 assertFalse(GrouperClientWs.mostRecentRequest,
28783 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28784 assertTrue(GrouperClientWs.mostRecentRequest,
28785 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28786 assertTrue(GrouperClientWs.mostRecentRequest,
28787 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28788 assertTrue(GrouperClientWs.mostRecentRequest,
28789 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28790 assertTrue(GrouperClientWs.mostRecentRequest,
28791 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
28792
28793
28794 } finally {
28795 System.setOut(systemOut);
28796 }
28797
28798 }
28799
28800
28801
28802
28803 public void testGetAttributeAssignsAttributeDefExtraFeatures() throws Exception {
28804
28805 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
28806 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
28807
28808 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
28809
28810 attributeDef.setValueType(AttributeDefValueType.string);
28811 attributeDef.setAssignToAttributeDef(true);
28812 attributeDef.store();
28813
28814 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
28815
28816 attributeDef2.setAssignToGroup(false);
28817 attributeDef2.setAssignToAttributeDefAssn(true);
28818 attributeDef2.setValueType(AttributeDefValueType.integer);
28819 attributeDef2.store();
28820
28821 AttributeDef ownerAttributeDef = new AttributeDefSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
28822 .assignName("test:attributeDefTestAttrAssign").assignCreateParentStemsIfNotExist(true)
28823 .assignDescription("description").save();
28824
28825
28826 attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
28827
28828 AttributeAssignResult attributeAssignResult = ownerAttributeDef.getAttributeDelegate().assignAttribute(attributeDefName);
28829 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
28830 attributeAssign.getValueDelegate().assignValue("abc");
28831
28832 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
28833 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
28834 attributeAssign2.getValueDelegate().assignValue("123");
28835
28836 PrintStream systemOut = System.out;
28837
28838 ByteArrayOutputStream baos = new ByteArrayOutputStream();
28839 System.setOut(new PrintStream(baos));
28840
28841 try {
28842
28843 GrouperClient.main(GrouperClientUtils.splitTrim(
28844 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def " +
28845 "--attributeDefNames=test:testAttributeAssignDefNameDef " +
28846 "--attributeDefValueType=string --value=abc",
28847 " "));
28848 System.out.flush();
28849 String output = new String(baos.toByteArray());
28850
28851 System.setOut(systemOut);
28852
28853 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
28854
28855
28856
28857 Pattern pattern = Pattern
28858 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28859
28860 assertEquals(1, GrouperUtil.length(outputLines));
28861 String outputLine = outputLines[0];
28862
28863 Matcher matcher = pattern.matcher(outputLines[0]);
28864
28865 assertTrue(outputLine, matcher.matches());
28866 assertEquals(outputLine, "0", matcher.group(1));
28867 assertEquals(outputLine, "attr_def", matcher.group(2));
28868 assertEquals(outputLine, "test:attributeDefTestAttrAssign", matcher.group(3));
28869 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
28870 assertEquals(outputLine, "assign", matcher.group(5));
28871 assertEquals(outputLine, "abc", matcher.group(6));
28872 assertEquals(outputLine, "T", matcher.group(7));
28873 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
28874
28875 assertTrue(GrouperClientWs.mostRecentRequest,
28876 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28877 assertTrue(GrouperClientWs.mostRecentRequest,
28878 !GrouperClientWs.mostRecentRequest.contains("actions"));
28879 assertTrue(GrouperClientWs.mostRecentRequest,
28880 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28881 assertTrue(GrouperClientWs.mostRecentRequest,
28882 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28883 assertTrue(GrouperClientWs.mostRecentRequest,
28884 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28885 assertTrue(GrouperClientWs.mostRecentRequest,
28886 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28887 assertTrue(GrouperClientWs.mostRecentRequest,
28888 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28889 assertTrue(GrouperClientWs.mostRecentRequest,
28890 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28891 assertTrue(GrouperClientWs.mostRecentRequest,
28892 !GrouperClientWs.mostRecentRequest.contains("params"));
28893 assertTrue(GrouperClientWs.mostRecentRequest,
28894 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28895 assertTrue(GrouperClientWs.mostRecentRequest,
28896 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28897 assertTrue(GrouperClientWs.mostRecentRequest,
28898 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
28899 assertTrue(GrouperClientWs.mostRecentRequest,
28900 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28901 assertTrue(GrouperClientWs.mostRecentRequest,
28902 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28903 assertTrue(GrouperClientWs.mostRecentRequest,
28904 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28905 assertTrue(GrouperClientWs.mostRecentRequest,
28906 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28907 assertTrue(GrouperClientWs.mostRecentRequest,
28908 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28909 assertTrue(GrouperClientWs.mostRecentRequest,
28910 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28911 assertTrue(GrouperClientWs.mostRecentRequest,
28912 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28913 assertTrue(GrouperClientWs.mostRecentRequest,
28914 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28915 assertTrue(GrouperClientWs.mostRecentRequest,
28916 GrouperClientWs.mostRecentRequest.contains("theValue"));
28917 assertTrue(GrouperClientWs.mostRecentRequest,
28918 GrouperClientWs.mostRecentRequest.contains("abc"));
28919 assertTrue(GrouperClientWs.mostRecentRequest,
28920 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28921 assertTrue(GrouperClientWs.mostRecentRequest,
28922 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28923 assertTrue(GrouperClientWs.mostRecentRequest,
28924 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28925 assertTrue(GrouperClientWs.mostRecentRequest,
28926 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28927 assertTrue(GrouperClientWs.mostRecentRequest,
28928 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
28929 assertTrue(GrouperClientWs.mostRecentRequest,
28930 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28931 assertTrue(GrouperClientWs.mostRecentRequest,
28932 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
28933 assertTrue(GrouperClientWs.mostRecentRequest,
28934 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28935
28936
28937
28938
28939 baos = new ByteArrayOutputStream();
28940 System.setOut(new PrintStream(baos));
28941
28942 GrouperClient.main(GrouperClientUtils.splitTrim(
28943 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=" + attributeDef.getId() +
28944 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
28945 "--attributeDefValueType=string --value=123",
28946 " "));
28947
28948
28949 System.out.flush();
28950 output = new String(baos.toByteArray());
28951
28952 System.setOut(systemOut);
28953
28954 outputLines = GrouperClientUtils.splitTrim(output, "\n");
28955
28956 assertEquals(0, GrouperUtil.length(outputLines));
28957
28958
28959
28960
28961 assertTrue(GrouperClientWs.mostRecentRequest,
28962 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28963 assertTrue(GrouperClientWs.mostRecentRequest,
28964 !GrouperClientWs.mostRecentRequest.contains("actions"));
28965 assertTrue(GrouperClientWs.mostRecentRequest,
28966 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28967 assertTrue(GrouperClientWs.mostRecentRequest,
28968 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28969 assertTrue(GrouperClientWs.mostRecentRequest,
28970 !GrouperClientWs.mostRecentRequest.contains("enabled"));
28971 assertTrue(GrouperClientWs.mostRecentRequest,
28972 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28973 assertTrue(GrouperClientWs.mostRecentRequest,
28974 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28975 assertTrue(GrouperClientWs.mostRecentRequest,
28976 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28977 assertTrue(GrouperClientWs.mostRecentRequest,
28978 !GrouperClientWs.mostRecentRequest.contains("params"));
28979 assertTrue(GrouperClientWs.mostRecentRequest,
28980 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28981 assertTrue(GrouperClientWs.mostRecentRequest,
28982 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28983 assertTrue(GrouperClientWs.mostRecentRequest,
28984 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
28985 assertTrue(GrouperClientWs.mostRecentRequest,
28986 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28987 assertTrue(GrouperClientWs.mostRecentRequest,
28988 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28989 assertTrue(GrouperClientWs.mostRecentRequest,
28990 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28991 assertTrue(GrouperClientWs.mostRecentRequest,
28992 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28993 assertTrue(GrouperClientWs.mostRecentRequest,
28994 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28995 assertTrue(GrouperClientWs.mostRecentRequest,
28996 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28997 assertTrue(GrouperClientWs.mostRecentRequest,
28998 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28999 assertTrue(GrouperClientWs.mostRecentRequest,
29000 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29001 assertTrue(GrouperClientWs.mostRecentRequest,
29002 GrouperClientWs.mostRecentRequest.contains("theValue"));
29003 assertTrue(GrouperClientWs.mostRecentRequest,
29004 GrouperClientWs.mostRecentRequest.contains(">123<"));
29005 assertTrue(GrouperClientWs.mostRecentRequest,
29006 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29007 assertTrue(GrouperClientWs.mostRecentRequest,
29008 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29009 assertTrue(GrouperClientWs.mostRecentRequest,
29010 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29011 assertTrue(GrouperClientWs.mostRecentRequest,
29012 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29013 assertTrue(GrouperClientWs.mostRecentRequest,
29014 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29015 assertTrue(GrouperClientWs.mostRecentRequest,
29016 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29017 assertTrue(GrouperClientWs.mostRecentRequest,
29018 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29019 assertTrue(GrouperClientWs.mostRecentRequest,
29020 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29021
29022
29023
29024
29025
29026 baos = new ByteArrayOutputStream();
29027 System.setOut(new PrintStream(baos));
29028
29029 try {
29030 GrouperClient.main(GrouperClientUtils.splitTrim(
29031 " --operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=123" + attributeDef.getId() +
29032 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
29033 "--attributeDefValueType=string --value=123",
29034 " "));
29035 fail("Shouldnt get here");
29036 } catch (GcWebServiceError gwse) {
29037
29038 }
29039
29040
29041
29042
29043 baos = new ByteArrayOutputStream();
29044 System.setOut(new PrintStream(baos));
29045
29046 GrouperClient.main(GrouperClientUtils.splitTrim(
29047 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=" + attributeDef.getId() +
29048 " --attributeDefValueType=string --value=abc --attributeDefType=attr",
29049 " "));
29050
29051
29052 System.out.flush();
29053 output = new String(baos.toByteArray());
29054
29055 System.setOut(systemOut);
29056
29057 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29058
29059
29060
29061 pattern = Pattern
29062 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29063
29064 assertEquals(1, GrouperUtil.length(outputLines));
29065 outputLine = outputLines[0];
29066
29067 matcher = pattern.matcher(outputLines[0]);
29068
29069 assertTrue(outputLine, matcher.matches());
29070 assertEquals(outputLine, "0", matcher.group(1));
29071 assertEquals(outputLine, "attr_def", matcher.group(2));
29072 assertEquals(outputLine, "test:attributeDefTestAttrAssign", matcher.group(3));
29073 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
29074 assertEquals(outputLine, "assign", matcher.group(5));
29075 assertEquals(outputLine, "abc", matcher.group(6));
29076 assertEquals(outputLine, "T", matcher.group(7));
29077 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
29078
29079 assertTrue(GrouperClientWs.mostRecentRequest,
29080 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29081 assertTrue(GrouperClientWs.mostRecentRequest,
29082 !GrouperClientWs.mostRecentRequest.contains("actions"));
29083 assertTrue(GrouperClientWs.mostRecentRequest,
29084 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29085 assertTrue(GrouperClientWs.mostRecentRequest,
29086 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29087 assertTrue(GrouperClientWs.mostRecentRequest,
29088 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29089 assertTrue(GrouperClientWs.mostRecentRequest,
29090 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29091 assertTrue(GrouperClientWs.mostRecentRequest,
29092 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29093 assertTrue(GrouperClientWs.mostRecentRequest,
29094 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29095 assertTrue(GrouperClientWs.mostRecentRequest,
29096 !GrouperClientWs.mostRecentRequest.contains("params"));
29097 assertTrue(GrouperClientWs.mostRecentRequest,
29098 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29099 assertTrue(GrouperClientWs.mostRecentRequest,
29100 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29101 assertTrue(GrouperClientWs.mostRecentRequest,
29102 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29103 assertTrue(GrouperClientWs.mostRecentRequest,
29104 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29105 assertTrue(GrouperClientWs.mostRecentRequest,
29106 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29107 assertTrue(GrouperClientWs.mostRecentRequest,
29108 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29109 assertTrue(GrouperClientWs.mostRecentRequest,
29110 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29111 assertTrue(GrouperClientWs.mostRecentRequest,
29112 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29113 assertTrue(GrouperClientWs.mostRecentRequest,
29114 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29115 assertTrue(GrouperClientWs.mostRecentRequest,
29116 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29117 assertTrue(GrouperClientWs.mostRecentRequest,
29118 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29119 assertTrue(GrouperClientWs.mostRecentRequest,
29120 GrouperClientWs.mostRecentRequest.contains("theValue"));
29121 assertTrue(GrouperClientWs.mostRecentRequest,
29122 GrouperClientWs.mostRecentRequest.contains("abc"));
29123 assertTrue(GrouperClientWs.mostRecentRequest,
29124 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29125 assertTrue(GrouperClientWs.mostRecentRequest,
29126 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29127 assertTrue(GrouperClientWs.mostRecentRequest,
29128 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29129 assertTrue(GrouperClientWs.mostRecentRequest,
29130 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29131 assertTrue(GrouperClientWs.mostRecentRequest,
29132 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29133 assertTrue(GrouperClientWs.mostRecentRequest,
29134 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29135 assertTrue(GrouperClientWs.mostRecentRequest,
29136 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29137 assertTrue(GrouperClientWs.mostRecentRequest,
29138 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29139
29140
29141
29142
29143 baos = new ByteArrayOutputStream();
29144 System.setOut(new PrintStream(baos));
29145
29146 GrouperClient.main(GrouperClientUtils.splitTrim(
29147 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=" + attributeDef.getId() +
29148 " --attributeDefValueType=string --value=abc --attributeDefType=limit",
29149 " "));
29150
29151 System.out.flush();
29152 output = new String(baos.toByteArray());
29153
29154 System.setOut(systemOut);
29155
29156 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29157
29158
29159
29160 pattern = Pattern
29161 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29162
29163 assertEquals(0, GrouperUtil.length(outputLines));
29164
29165 assertTrue(GrouperClientWs.mostRecentRequest,
29166 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29167 assertTrue(GrouperClientWs.mostRecentRequest,
29168 !GrouperClientWs.mostRecentRequest.contains("actions"));
29169 assertTrue(GrouperClientWs.mostRecentRequest,
29170 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29171 assertTrue(GrouperClientWs.mostRecentRequest,
29172 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29173 assertTrue(GrouperClientWs.mostRecentRequest,
29174 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29175 assertTrue(GrouperClientWs.mostRecentRequest,
29176 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29177 assertTrue(GrouperClientWs.mostRecentRequest,
29178 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29179 assertTrue(GrouperClientWs.mostRecentRequest,
29180 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29181 assertTrue(GrouperClientWs.mostRecentRequest,
29182 !GrouperClientWs.mostRecentRequest.contains("params"));
29183 assertTrue(GrouperClientWs.mostRecentRequest,
29184 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29185 assertTrue(GrouperClientWs.mostRecentRequest,
29186 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29187 assertTrue(GrouperClientWs.mostRecentRequest,
29188 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29189 assertTrue(GrouperClientWs.mostRecentRequest,
29190 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29191 assertTrue(GrouperClientWs.mostRecentRequest,
29192 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29193 assertTrue(GrouperClientWs.mostRecentRequest,
29194 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29195 assertTrue(GrouperClientWs.mostRecentRequest,
29196 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29197 assertTrue(GrouperClientWs.mostRecentRequest,
29198 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29199 assertTrue(GrouperClientWs.mostRecentRequest,
29200 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29201 assertTrue(GrouperClientWs.mostRecentRequest,
29202 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29203 assertTrue(GrouperClientWs.mostRecentRequest,
29204 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29205 assertTrue(GrouperClientWs.mostRecentRequest,
29206 GrouperClientWs.mostRecentRequest.contains("theValue"));
29207 assertTrue(GrouperClientWs.mostRecentRequest,
29208 GrouperClientWs.mostRecentRequest.contains("abc"));
29209 assertTrue(GrouperClientWs.mostRecentRequest,
29210 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29211 assertTrue(GrouperClientWs.mostRecentRequest,
29212 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29213 assertTrue(GrouperClientWs.mostRecentRequest,
29214 GrouperClientWs.mostRecentRequest.contains("limit"));
29215 assertTrue(GrouperClientWs.mostRecentRequest,
29216 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29217 assertTrue(GrouperClientWs.mostRecentRequest,
29218 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29219 assertTrue(GrouperClientWs.mostRecentRequest,
29220 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29221 assertTrue(GrouperClientWs.mostRecentRequest,
29222 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29223 assertTrue(GrouperClientWs.mostRecentRequest,
29224 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29225 assertTrue(GrouperClientWs.mostRecentRequest,
29226 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29227
29228
29229
29230
29231 baos = new ByteArrayOutputStream();
29232 System.setOut(new PrintStream(baos));
29233
29234 GrouperClient.main(GrouperClientUtils.splitTrim(
29235 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId(),
29236 " "));
29237
29238 System.out.flush();
29239 output = new String(baos.toByteArray());
29240
29241 System.setOut(systemOut);
29242
29243 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29244
29245
29246
29247 pattern = Pattern
29248 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29249
29250 assertEquals(1, GrouperUtil.length(outputLines));
29251 outputLine = outputLines[0];
29252
29253 matcher = pattern.matcher(outputLines[0]);
29254
29255 assertTrue(outputLine, matcher.matches());
29256 assertEquals(outputLine, "0", matcher.group(1));
29257 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29258 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29259 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29260 assertEquals(outputLine, "assign", matcher.group(5));
29261 assertEquals(outputLine, "123", matcher.group(6));
29262 assertEquals(outputLine, "T", matcher.group(7));
29263 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29264
29265 assertTrue(GrouperClientWs.mostRecentRequest,
29266 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29267 assertTrue(GrouperClientWs.mostRecentRequest,
29268 !GrouperClientWs.mostRecentRequest.contains("actions"));
29269 assertTrue(GrouperClientWs.mostRecentRequest,
29270 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29271 assertTrue(GrouperClientWs.mostRecentRequest,
29272 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29273 assertTrue(GrouperClientWs.mostRecentRequest,
29274 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29275 assertTrue(GrouperClientWs.mostRecentRequest,
29276 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29277 assertTrue(GrouperClientWs.mostRecentRequest,
29278 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29279 assertTrue(GrouperClientWs.mostRecentRequest,
29280 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29281 assertTrue(GrouperClientWs.mostRecentRequest,
29282 !GrouperClientWs.mostRecentRequest.contains("params"));
29283 assertTrue(GrouperClientWs.mostRecentRequest,
29284 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29285 assertTrue(GrouperClientWs.mostRecentRequest,
29286 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29287 assertTrue(GrouperClientWs.mostRecentRequest,
29288 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29289 assertTrue(GrouperClientWs.mostRecentRequest,
29290 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29291 assertTrue(GrouperClientWs.mostRecentRequest,
29292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29293 assertTrue(GrouperClientWs.mostRecentRequest,
29294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29295 assertTrue(GrouperClientWs.mostRecentRequest,
29296 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29297 assertTrue(GrouperClientWs.mostRecentRequest,
29298 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29299 assertTrue(GrouperClientWs.mostRecentRequest,
29300 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29301 assertTrue(GrouperClientWs.mostRecentRequest,
29302 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29303 assertFalse(GrouperClientWs.mostRecentRequest,
29304 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29305 assertFalse(GrouperClientWs.mostRecentRequest,
29306 GrouperClientWs.mostRecentRequest.contains("theValue"));
29307 assertFalse(GrouperClientWs.mostRecentRequest,
29308 GrouperClientWs.mostRecentRequest.contains(">abc<"));
29309 assertTrue(GrouperClientWs.mostRecentRequest,
29310 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29311 assertFalse(GrouperClientWs.mostRecentRequest,
29312 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29313 assertTrue(GrouperClientWs.mostRecentRequest,
29314 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29315 assertTrue(GrouperClientWs.mostRecentRequest,
29316 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29317 assertTrue(GrouperClientWs.mostRecentRequest,
29318 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29319 assertTrue(GrouperClientWs.mostRecentRequest,
29320 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29321 assertTrue(GrouperClientWs.mostRecentRequest,
29322 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29323 assertTrue(GrouperClientWs.mostRecentRequest,
29324 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29325
29326
29327
29328
29329 baos = new ByteArrayOutputStream();
29330 System.setOut(new PrintStream(baos));
29331
29332 try {
29333 GrouperClient.main(GrouperClientUtils.splitTrim(
29334 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=1" + attributeDef2.getId(),
29335 " "));
29336
29337 System.out.flush();
29338 output = new String(baos.toByteArray());
29339
29340 System.setOut(systemOut);
29341
29342 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29343
29344
29345
29346 pattern = Pattern
29347 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29348
29349 assertEquals(0, GrouperUtil.length(outputLines));
29350 fail("Why did it not fail?");
29351 } catch (Exception e) {
29352
29353 }
29354 assertTrue(GrouperClientWs.mostRecentRequest,
29355 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29356 assertTrue(GrouperClientWs.mostRecentRequest,
29357 !GrouperClientWs.mostRecentRequest.contains("actions"));
29358 assertTrue(GrouperClientWs.mostRecentRequest,
29359 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29360 assertTrue(GrouperClientWs.mostRecentRequest,
29361 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29362 assertTrue(GrouperClientWs.mostRecentRequest,
29363 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29364 assertTrue(GrouperClientWs.mostRecentRequest,
29365 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29366 assertTrue(GrouperClientWs.mostRecentRequest,
29367 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29368 assertTrue(GrouperClientWs.mostRecentRequest,
29369 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29370 assertTrue(GrouperClientWs.mostRecentRequest,
29371 !GrouperClientWs.mostRecentRequest.contains("params"));
29372 assertTrue(GrouperClientWs.mostRecentRequest,
29373 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29374 assertTrue(GrouperClientWs.mostRecentRequest,
29375 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29376 assertTrue(GrouperClientWs.mostRecentRequest,
29377 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29378 assertTrue(GrouperClientWs.mostRecentRequest,
29379 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29380 assertTrue(GrouperClientWs.mostRecentRequest,
29381 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29382 assertTrue(GrouperClientWs.mostRecentRequest,
29383 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29384 assertTrue(GrouperClientWs.mostRecentRequest,
29385 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29386 assertTrue(GrouperClientWs.mostRecentRequest,
29387 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29388 assertTrue(GrouperClientWs.mostRecentRequest,
29389 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29390 assertTrue(GrouperClientWs.mostRecentRequest,
29391 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29392 assertFalse(GrouperClientWs.mostRecentRequest,
29393 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29394 assertFalse(GrouperClientWs.mostRecentRequest,
29395 GrouperClientWs.mostRecentRequest.contains("theValue"));
29396 assertFalse(GrouperClientWs.mostRecentRequest,
29397 GrouperClientWs.mostRecentRequest.contains("abc"));
29398 assertTrue(GrouperClientWs.mostRecentRequest,
29399 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29400 assertFalse(GrouperClientWs.mostRecentRequest,
29401 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29402 assertTrue(GrouperClientWs.mostRecentRequest,
29403 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29404 assertTrue(GrouperClientWs.mostRecentRequest,
29405 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29406 assertTrue(GrouperClientWs.mostRecentRequest,
29407 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29408 assertTrue(GrouperClientWs.mostRecentRequest,
29409 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29410 assertTrue(GrouperClientWs.mostRecentRequest,
29411 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29412 assertTrue(GrouperClientWs.mostRecentRequest,
29413 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29414
29415
29416
29417
29418
29419 baos = new ByteArrayOutputStream();
29420 System.setOut(new PrintStream(baos));
29421
29422 GrouperClient.main(GrouperClientUtils.splitTrim(
29423 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId()
29424 + " --attributeDefValueType=integer --value=123 ",
29425 " "));
29426
29427 System.out.flush();
29428 output = new String(baos.toByteArray());
29429
29430 System.setOut(systemOut);
29431
29432 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29433
29434
29435
29436 pattern = Pattern
29437 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29438
29439 assertEquals(1, GrouperUtil.length(outputLines));
29440 outputLine = outputLines[0];
29441
29442 matcher = pattern.matcher(outputLines[0]);
29443
29444 assertTrue(outputLine, matcher.matches());
29445 assertEquals(outputLine, "0", matcher.group(1));
29446 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29447 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29448 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29449 assertEquals(outputLine, "assign", matcher.group(5));
29450 assertEquals(outputLine, "123", matcher.group(6));
29451 assertEquals(outputLine, "T", matcher.group(7));
29452 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29453
29454 assertTrue(GrouperClientWs.mostRecentRequest,
29455 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29456 assertTrue(GrouperClientWs.mostRecentRequest,
29457 !GrouperClientWs.mostRecentRequest.contains("actions"));
29458 assertTrue(GrouperClientWs.mostRecentRequest,
29459 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29460 assertTrue(GrouperClientWs.mostRecentRequest,
29461 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29462 assertTrue(GrouperClientWs.mostRecentRequest,
29463 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29464 assertTrue(GrouperClientWs.mostRecentRequest,
29465 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29466 assertTrue(GrouperClientWs.mostRecentRequest,
29467 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29468 assertTrue(GrouperClientWs.mostRecentRequest,
29469 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29470 assertTrue(GrouperClientWs.mostRecentRequest,
29471 !GrouperClientWs.mostRecentRequest.contains("params"));
29472 assertTrue(GrouperClientWs.mostRecentRequest,
29473 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29474 assertTrue(GrouperClientWs.mostRecentRequest,
29475 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29476 assertTrue(GrouperClientWs.mostRecentRequest,
29477 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29478 assertTrue(GrouperClientWs.mostRecentRequest,
29479 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29480 assertTrue(GrouperClientWs.mostRecentRequest,
29481 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29482 assertTrue(GrouperClientWs.mostRecentRequest,
29483 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29484 assertTrue(GrouperClientWs.mostRecentRequest,
29485 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29486 assertTrue(GrouperClientWs.mostRecentRequest,
29487 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29488 assertTrue(GrouperClientWs.mostRecentRequest,
29489 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29490 assertTrue(GrouperClientWs.mostRecentRequest,
29491 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29492 assertTrue(GrouperClientWs.mostRecentRequest,
29493 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29494 assertTrue(GrouperClientWs.mostRecentRequest,
29495 GrouperClientWs.mostRecentRequest.contains("theValue"));
29496 assertTrue(GrouperClientWs.mostRecentRequest,
29497 GrouperClientWs.mostRecentRequest.contains(">123<"));
29498 assertTrue(GrouperClientWs.mostRecentRequest,
29499 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29500 assertFalse(GrouperClientWs.mostRecentRequest,
29501 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29502 assertTrue(GrouperClientWs.mostRecentRequest,
29503 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29504 assertTrue(GrouperClientWs.mostRecentRequest,
29505 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29506 assertTrue(GrouperClientWs.mostRecentRequest,
29507 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29508 assertTrue(GrouperClientWs.mostRecentRequest,
29509 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29510 assertTrue(GrouperClientWs.mostRecentRequest,
29511 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29512 assertTrue(GrouperClientWs.mostRecentRequest,
29513 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29514
29515
29516
29517
29518
29519 baos = new ByteArrayOutputStream();
29520 System.setOut(new PrintStream(baos));
29521
29522 GrouperClient.main(GrouperClientUtils.splitTrim(
29523 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId()
29524 + " --attributeDefValueType=integer --value=1234 ",
29525 " "));
29526
29527 System.out.flush();
29528 output = new String(baos.toByteArray());
29529
29530 System.setOut(systemOut);
29531
29532 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29533
29534
29535
29536 pattern = Pattern
29537 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29538
29539 assertEquals(0, GrouperUtil.length(outputLines));
29540
29541 assertTrue(GrouperClientWs.mostRecentRequest,
29542 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29543 assertTrue(GrouperClientWs.mostRecentRequest,
29544 !GrouperClientWs.mostRecentRequest.contains("actions"));
29545 assertTrue(GrouperClientWs.mostRecentRequest,
29546 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29547 assertTrue(GrouperClientWs.mostRecentRequest,
29548 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29549 assertTrue(GrouperClientWs.mostRecentRequest,
29550 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29551 assertTrue(GrouperClientWs.mostRecentRequest,
29552 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29553 assertTrue(GrouperClientWs.mostRecentRequest,
29554 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29555 assertTrue(GrouperClientWs.mostRecentRequest,
29556 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29557 assertTrue(GrouperClientWs.mostRecentRequest,
29558 !GrouperClientWs.mostRecentRequest.contains("params"));
29559 assertTrue(GrouperClientWs.mostRecentRequest,
29560 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29561 assertTrue(GrouperClientWs.mostRecentRequest,
29562 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29563 assertTrue(GrouperClientWs.mostRecentRequest,
29564 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29565 assertTrue(GrouperClientWs.mostRecentRequest,
29566 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29567 assertTrue(GrouperClientWs.mostRecentRequest,
29568 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29569 assertTrue(GrouperClientWs.mostRecentRequest,
29570 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29571 assertTrue(GrouperClientWs.mostRecentRequest,
29572 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29573 assertTrue(GrouperClientWs.mostRecentRequest,
29574 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29575 assertTrue(GrouperClientWs.mostRecentRequest,
29576 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29577 assertTrue(GrouperClientWs.mostRecentRequest,
29578 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29579 assertTrue(GrouperClientWs.mostRecentRequest,
29580 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29581 assertTrue(GrouperClientWs.mostRecentRequest,
29582 GrouperClientWs.mostRecentRequest.contains("theValue"));
29583 assertTrue(GrouperClientWs.mostRecentRequest,
29584 GrouperClientWs.mostRecentRequest.contains("1234"));
29585 assertTrue(GrouperClientWs.mostRecentRequest,
29586 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29587 assertFalse(GrouperClientWs.mostRecentRequest,
29588 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29589 assertTrue(GrouperClientWs.mostRecentRequest,
29590 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29591 assertTrue(GrouperClientWs.mostRecentRequest,
29592 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29593 assertTrue(GrouperClientWs.mostRecentRequest,
29594 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29595 assertTrue(GrouperClientWs.mostRecentRequest,
29596 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29597 assertTrue(GrouperClientWs.mostRecentRequest,
29598 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29599 assertTrue(GrouperClientWs.mostRecentRequest,
29600 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29601
29602
29603
29604
29605
29606 baos = new ByteArrayOutputStream();
29607 System.setOut(new PrintStream(baos));
29608
29609 GrouperClient.main(GrouperClientUtils.splitTrim(
29610 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId()
29611 + " --includeAssignmentsFromAssignments=T ",
29612 " "));
29613
29614 System.out.flush();
29615 output = new String(baos.toByteArray());
29616
29617 System.setOut(systemOut);
29618
29619 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29620
29621
29622
29623 pattern = Pattern
29624 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29625
29626 assertEquals(2, GrouperUtil.length(outputLines));
29627 outputLine = outputLines[0];
29628
29629 matcher = pattern.matcher(outputLine);
29630
29631 assertTrue(outputLine, matcher.matches());
29632 assertEquals(outputLine, "0", matcher.group(1));
29633 assertEquals(outputLine, "attr_def", matcher.group(2));
29634 assertEquals(outputLine, "test:attributeDefTestAttrAssign", matcher.group(3));
29635 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
29636 assertEquals(outputLine, "assign", matcher.group(5));
29637 assertEquals(outputLine, "abc", matcher.group(6));
29638 assertEquals(outputLine, "T", matcher.group(7));
29639 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
29640
29641 outputLine = outputLines[1];
29642
29643 matcher = pattern.matcher(outputLine);
29644
29645 assertTrue(outputLine, matcher.matches());
29646 assertEquals(outputLine, "1", matcher.group(1));
29647 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29648 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29649 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29650 assertEquals(outputLine, "assign", matcher.group(5));
29651 assertEquals(outputLine, "123", matcher.group(6));
29652 assertEquals(outputLine, "T", matcher.group(7));
29653 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29654
29655 assertTrue(GrouperClientWs.mostRecentRequest,
29656 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29657 assertTrue(GrouperClientWs.mostRecentRequest,
29658 !GrouperClientWs.mostRecentRequest.contains("actions"));
29659 assertTrue(GrouperClientWs.mostRecentRequest,
29660 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29661 assertTrue(GrouperClientWs.mostRecentRequest,
29662 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29663 assertTrue(GrouperClientWs.mostRecentRequest,
29664 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29665 assertTrue(GrouperClientWs.mostRecentRequest,
29666 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29667 assertTrue(GrouperClientWs.mostRecentRequest,
29668 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29669 assertTrue(GrouperClientWs.mostRecentRequest,
29670 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29671 assertTrue(GrouperClientWs.mostRecentRequest,
29672 !GrouperClientWs.mostRecentRequest.contains("params"));
29673 assertTrue(GrouperClientWs.mostRecentRequest,
29674 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29675 assertTrue(GrouperClientWs.mostRecentRequest,
29676 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29677 assertTrue(GrouperClientWs.mostRecentRequest,
29678 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29679 assertTrue(GrouperClientWs.mostRecentRequest,
29680 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29681 assertTrue(GrouperClientWs.mostRecentRequest,
29682 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29683 assertTrue(GrouperClientWs.mostRecentRequest,
29684 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29685 assertTrue(GrouperClientWs.mostRecentRequest,
29686 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29687 assertTrue(GrouperClientWs.mostRecentRequest,
29688 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29689 assertTrue(GrouperClientWs.mostRecentRequest,
29690 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29691 assertTrue(GrouperClientWs.mostRecentRequest,
29692 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29693 assertFalse(GrouperClientWs.mostRecentRequest,
29694 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29695 assertFalse(GrouperClientWs.mostRecentRequest,
29696 GrouperClientWs.mostRecentRequest.contains("theValue"));
29697 assertFalse(GrouperClientWs.mostRecentRequest,
29698 GrouperClientWs.mostRecentRequest.contains(">123<"));
29699 assertTrue(GrouperClientWs.mostRecentRequest,
29700 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29701 assertFalse(GrouperClientWs.mostRecentRequest,
29702 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29703 assertTrue(GrouperClientWs.mostRecentRequest,
29704 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29705 assertTrue(GrouperClientWs.mostRecentRequest,
29706 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29707 assertTrue(GrouperClientWs.mostRecentRequest,
29708 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29709 assertTrue(GrouperClientWs.mostRecentRequest,
29710 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29711 assertTrue(GrouperClientWs.mostRecentRequest,
29712 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29713 assertTrue(GrouperClientWs.mostRecentRequest,
29714 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29715
29716
29717
29718
29719
29720 baos = new ByteArrayOutputStream();
29721 System.setOut(new PrintStream(baos));
29722
29723 try {
29724 GrouperClient.main(GrouperClientUtils.splitTrim(
29725 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
29726 ,
29727 " "));
29728
29729 System.out.flush();
29730 output = new String(baos.toByteArray());
29731
29732 System.setOut(systemOut);
29733
29734 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29735
29736
29737
29738 pattern = Pattern
29739 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29740
29741 assertEquals(0, GrouperUtil.length(outputLines));
29742 fail("Shouldnt get here");
29743 } catch (Exception e) {
29744
29745 } finally {
29746 System.setOut(systemOut);
29747
29748 }
29749
29750 assertTrue(GrouperClientWs.mostRecentRequest,
29751 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29752 assertTrue(GrouperClientWs.mostRecentRequest,
29753 !GrouperClientWs.mostRecentRequest.contains("actions"));
29754 assertTrue(GrouperClientWs.mostRecentRequest,
29755 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29756 assertTrue(GrouperClientWs.mostRecentRequest,
29757 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29758 assertTrue(GrouperClientWs.mostRecentRequest,
29759 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29760 assertTrue(GrouperClientWs.mostRecentRequest,
29761 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29762 assertTrue(GrouperClientWs.mostRecentRequest,
29763 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29764 assertTrue(GrouperClientWs.mostRecentRequest,
29765 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29766 assertTrue(GrouperClientWs.mostRecentRequest,
29767 !GrouperClientWs.mostRecentRequest.contains("params"));
29768 assertTrue(GrouperClientWs.mostRecentRequest,
29769 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29770 assertTrue(GrouperClientWs.mostRecentRequest,
29771 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29772 assertFalse(GrouperClientWs.mostRecentRequest,
29773 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
29774 assertTrue(GrouperClientWs.mostRecentRequest,
29775 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29776 assertTrue(GrouperClientWs.mostRecentRequest,
29777 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29778 assertTrue(GrouperClientWs.mostRecentRequest,
29779 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29780 assertTrue(GrouperClientWs.mostRecentRequest,
29781 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29782 assertTrue(GrouperClientWs.mostRecentRequest,
29783 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29784 assertTrue(GrouperClientWs.mostRecentRequest,
29785 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29786 assertTrue(GrouperClientWs.mostRecentRequest,
29787 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29788 assertTrue(GrouperClientWs.mostRecentRequest,
29789 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29790 assertFalse(GrouperClientWs.mostRecentRequest,
29791 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29792 assertFalse(GrouperClientWs.mostRecentRequest,
29793 GrouperClientWs.mostRecentRequest.contains("theValue"));
29794 assertFalse(GrouperClientWs.mostRecentRequest,
29795 GrouperClientWs.mostRecentRequest.contains(">123<"));
29796 assertFalse(GrouperClientWs.mostRecentRequest,
29797 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29798 assertFalse(GrouperClientWs.mostRecentRequest,
29799 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29800 assertTrue(GrouperClientWs.mostRecentRequest,
29801 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29802 assertTrue(GrouperClientWs.mostRecentRequest,
29803 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29804 assertTrue(GrouperClientWs.mostRecentRequest,
29805 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29806 assertTrue(GrouperClientWs.mostRecentRequest,
29807 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29808 assertTrue(GrouperClientWs.mostRecentRequest,
29809 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29810 assertTrue(GrouperClientWs.mostRecentRequest,
29811 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29812
29813
29814
29815
29816 baos = new ByteArrayOutputStream();
29817 System.setOut(new PrintStream(baos));
29818
29819 GrouperClient.main(GrouperClientUtils.splitTrim(
29820 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
29821 ,
29822 " "));
29823
29824 System.out.flush();
29825 output = new String(baos.toByteArray());
29826
29827 System.setOut(systemOut);
29828
29829 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29830
29831
29832
29833 pattern = Pattern
29834 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29835
29836 assertEquals(1, GrouperUtil.length(outputLines));
29837
29838 outputLine = outputLines[0];
29839
29840 matcher = pattern.matcher(outputLine);
29841
29842 assertTrue(outputLine, matcher.matches());
29843 assertEquals(outputLine, "0", matcher.group(1));
29844 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29845 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29846 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29847 assertEquals(outputLine, "assign", matcher.group(5));
29848 assertEquals(outputLine, "123", matcher.group(6));
29849 assertEquals(outputLine, "T", matcher.group(7));
29850 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29851
29852 assertTrue(GrouperClientWs.mostRecentRequest,
29853 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29854 assertTrue(GrouperClientWs.mostRecentRequest,
29855 !GrouperClientWs.mostRecentRequest.contains("actions"));
29856 assertTrue(GrouperClientWs.mostRecentRequest,
29857 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29858 assertTrue(GrouperClientWs.mostRecentRequest,
29859 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29860 assertTrue(GrouperClientWs.mostRecentRequest,
29861 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29862 assertTrue(GrouperClientWs.mostRecentRequest,
29863 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29864 assertTrue(GrouperClientWs.mostRecentRequest,
29865 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29866 assertTrue(GrouperClientWs.mostRecentRequest,
29867 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29868 assertTrue(GrouperClientWs.mostRecentRequest,
29869 !GrouperClientWs.mostRecentRequest.contains("params"));
29870 assertTrue(GrouperClientWs.mostRecentRequest,
29871 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29872 assertTrue(GrouperClientWs.mostRecentRequest,
29873 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29874 assertFalse(GrouperClientWs.mostRecentRequest,
29875 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
29876 assertTrue(GrouperClientWs.mostRecentRequest,
29877 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29878 assertTrue(GrouperClientWs.mostRecentRequest,
29879 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29880 assertTrue(GrouperClientWs.mostRecentRequest,
29881 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29882 assertTrue(GrouperClientWs.mostRecentRequest,
29883 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29884 assertTrue(GrouperClientWs.mostRecentRequest,
29885 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29886 assertTrue(GrouperClientWs.mostRecentRequest,
29887 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29888 assertTrue(GrouperClientWs.mostRecentRequest,
29889 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29890 assertTrue(GrouperClientWs.mostRecentRequest,
29891 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29892 assertFalse(GrouperClientWs.mostRecentRequest,
29893 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29894 assertFalse(GrouperClientWs.mostRecentRequest,
29895 GrouperClientWs.mostRecentRequest.contains("theValue"));
29896 assertFalse(GrouperClientWs.mostRecentRequest,
29897 GrouperClientWs.mostRecentRequest.contains(">123<"));
29898 assertFalse(GrouperClientWs.mostRecentRequest,
29899 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29900 assertFalse(GrouperClientWs.mostRecentRequest,
29901 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29902 assertTrue(GrouperClientWs.mostRecentRequest,
29903 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29904 assertTrue(GrouperClientWs.mostRecentRequest,
29905 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29906 assertTrue(GrouperClientWs.mostRecentRequest,
29907 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29908 assertTrue(GrouperClientWs.mostRecentRequest,
29909 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29910 assertTrue(GrouperClientWs.mostRecentRequest,
29911 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29912 assertTrue(GrouperClientWs.mostRecentRequest,
29913 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29914
29915
29916
29917
29918
29919 baos = new ByteArrayOutputStream();
29920 System.setOut(new PrintStream(baos));
29921
29922 GrouperClient.main(GrouperClientUtils.splitTrim(
29923 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
29924 ,
29925 " "));
29926
29927 System.out.flush();
29928 output = new String(baos.toByteArray());
29929
29930 System.setOut(systemOut);
29931
29932 outputLines = GrouperClientUtils.splitTrim(output, "\n");
29933
29934
29935
29936 pattern = Pattern
29937 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29938
29939 assertEquals(1, GrouperUtil.length(outputLines));
29940
29941 outputLine = outputLines[0];
29942
29943 matcher = pattern.matcher(outputLine);
29944
29945 assertTrue(outputLine, matcher.matches());
29946 assertEquals(outputLine, "0", matcher.group(1));
29947 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29948 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29949 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29950 assertEquals(outputLine, "assign", matcher.group(5));
29951 assertEquals(outputLine, "123", matcher.group(6));
29952 assertEquals(outputLine, "T", matcher.group(7));
29953 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29954
29955 assertTrue(GrouperClientWs.mostRecentRequest,
29956 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29957 assertTrue(GrouperClientWs.mostRecentRequest,
29958 !GrouperClientWs.mostRecentRequest.contains("actions"));
29959 assertTrue(GrouperClientWs.mostRecentRequest,
29960 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29961 assertTrue(GrouperClientWs.mostRecentRequest,
29962 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29963 assertTrue(GrouperClientWs.mostRecentRequest,
29964 !GrouperClientWs.mostRecentRequest.contains("enabled"));
29965 assertTrue(GrouperClientWs.mostRecentRequest,
29966 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29967 assertTrue(GrouperClientWs.mostRecentRequest,
29968 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29969 assertTrue(GrouperClientWs.mostRecentRequest,
29970 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29971 assertTrue(GrouperClientWs.mostRecentRequest,
29972 !GrouperClientWs.mostRecentRequest.contains("params"));
29973 assertTrue(GrouperClientWs.mostRecentRequest,
29974 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29975 assertTrue(GrouperClientWs.mostRecentRequest,
29976 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29977 assertFalse(GrouperClientWs.mostRecentRequest,
29978 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
29979 assertFalse(GrouperClientWs.mostRecentRequest,
29980 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29981 assertTrue(GrouperClientWs.mostRecentRequest,
29982 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29983 assertTrue(GrouperClientWs.mostRecentRequest,
29984 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29985 assertTrue(GrouperClientWs.mostRecentRequest,
29986 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29987 assertTrue(GrouperClientWs.mostRecentRequest,
29988 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29989 assertTrue(GrouperClientWs.mostRecentRequest,
29990 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29991 assertTrue(GrouperClientWs.mostRecentRequest,
29992 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29993 assertTrue(GrouperClientWs.mostRecentRequest,
29994 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29995 assertFalse(GrouperClientWs.mostRecentRequest,
29996 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29997 assertFalse(GrouperClientWs.mostRecentRequest,
29998 GrouperClientWs.mostRecentRequest.contains("theValue"));
29999 assertFalse(GrouperClientWs.mostRecentRequest,
30000 GrouperClientWs.mostRecentRequest.contains(">123<"));
30001 assertFalse(GrouperClientWs.mostRecentRequest,
30002 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30003 assertFalse(GrouperClientWs.mostRecentRequest,
30004 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30005 assertTrue(GrouperClientWs.mostRecentRequest,
30006 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30007 assertTrue(GrouperClientWs.mostRecentRequest,
30008 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30009 assertTrue(GrouperClientWs.mostRecentRequest,
30010 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30011 assertTrue(GrouperClientWs.mostRecentRequest,
30012 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30013 assertTrue(GrouperClientWs.mostRecentRequest,
30014 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30015 assertTrue(GrouperClientWs.mostRecentRequest,
30016 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30017
30018
30019
30020
30021
30022
30023 baos = new ByteArrayOutputStream();
30024 System.setOut(new PrintStream(baos));
30025
30026 try {
30027 GrouperClient.main(GrouperClientUtils.splitTrim(
30028 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
30029 ,
30030 " "));
30031
30032 System.out.flush();
30033 output = new String(baos.toByteArray());
30034
30035 System.setOut(systemOut);
30036
30037 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30038
30039
30040
30041 pattern = Pattern
30042 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30043
30044 assertEquals(0, GrouperUtil.length(outputLines));
30045
30046 fail("shouldnt get here");
30047 } catch (Exception e) {
30048
30049 } finally {
30050 System.setOut(systemOut);
30051 }
30052
30053 assertTrue(GrouperClientWs.mostRecentRequest,
30054 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30055 assertTrue(GrouperClientWs.mostRecentRequest,
30056 !GrouperClientWs.mostRecentRequest.contains("actions"));
30057 assertTrue(GrouperClientWs.mostRecentRequest,
30058 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30059 assertTrue(GrouperClientWs.mostRecentRequest,
30060 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30061 assertTrue(GrouperClientWs.mostRecentRequest,
30062 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30063 assertTrue(GrouperClientWs.mostRecentRequest,
30064 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30065 assertTrue(GrouperClientWs.mostRecentRequest,
30066 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30067 assertTrue(GrouperClientWs.mostRecentRequest,
30068 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30069 assertTrue(GrouperClientWs.mostRecentRequest,
30070 !GrouperClientWs.mostRecentRequest.contains("params"));
30071 assertTrue(GrouperClientWs.mostRecentRequest,
30072 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30073 assertTrue(GrouperClientWs.mostRecentRequest,
30074 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30075 assertFalse(GrouperClientWs.mostRecentRequest,
30076 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30077 assertFalse(GrouperClientWs.mostRecentRequest,
30078 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30079 assertTrue(GrouperClientWs.mostRecentRequest,
30080 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30081 assertTrue(GrouperClientWs.mostRecentRequest,
30082 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30083 assertTrue(GrouperClientWs.mostRecentRequest,
30084 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30085 assertTrue(GrouperClientWs.mostRecentRequest,
30086 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30087 assertTrue(GrouperClientWs.mostRecentRequest,
30088 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30089 assertTrue(GrouperClientWs.mostRecentRequest,
30090 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30091 assertTrue(GrouperClientWs.mostRecentRequest,
30092 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30093 assertFalse(GrouperClientWs.mostRecentRequest,
30094 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30095 assertFalse(GrouperClientWs.mostRecentRequest,
30096 GrouperClientWs.mostRecentRequest.contains("theValue"));
30097 assertFalse(GrouperClientWs.mostRecentRequest,
30098 GrouperClientWs.mostRecentRequest.contains(">123<"));
30099 assertFalse(GrouperClientWs.mostRecentRequest,
30100 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30101 assertFalse(GrouperClientWs.mostRecentRequest,
30102 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30103 assertTrue(GrouperClientWs.mostRecentRequest,
30104 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30105 assertTrue(GrouperClientWs.mostRecentRequest,
30106 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30107 assertTrue(GrouperClientWs.mostRecentRequest,
30108 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30109 assertTrue(GrouperClientWs.mostRecentRequest,
30110 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30111 assertTrue(GrouperClientWs.mostRecentRequest,
30112 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30113 assertTrue(GrouperClientWs.mostRecentRequest,
30114 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30115
30116
30117
30118
30119
30120 baos = new ByteArrayOutputStream();
30121 System.setOut(new PrintStream(baos));
30122
30123 GrouperClient.main(GrouperClientUtils.splitTrim(
30124 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
30125 ,
30126 " "));
30127
30128 System.out.flush();
30129 output = new String(baos.toByteArray());
30130
30131 System.setOut(systemOut);
30132
30133 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30134
30135
30136
30137 pattern = Pattern
30138 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30139
30140 assertEquals(1, GrouperUtil.length(outputLines));
30141
30142 outputLine = outputLines[0];
30143
30144 matcher = pattern.matcher(outputLine);
30145
30146 assertTrue(outputLine, matcher.matches());
30147 assertEquals(outputLine, "0", matcher.group(1));
30148 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30149 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30150 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30151 assertEquals(outputLine, "assign", matcher.group(5));
30152 assertEquals(outputLine, "123", matcher.group(6));
30153 assertEquals(outputLine, "T", matcher.group(7));
30154 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30155
30156 assertTrue(GrouperClientWs.mostRecentRequest,
30157 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30158 assertTrue(GrouperClientWs.mostRecentRequest,
30159 !GrouperClientWs.mostRecentRequest.contains("actions"));
30160 assertTrue(GrouperClientWs.mostRecentRequest,
30161 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30162 assertTrue(GrouperClientWs.mostRecentRequest,
30163 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30164 assertTrue(GrouperClientWs.mostRecentRequest,
30165 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30166 assertTrue(GrouperClientWs.mostRecentRequest,
30167 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30168 assertTrue(GrouperClientWs.mostRecentRequest,
30169 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30170 assertTrue(GrouperClientWs.mostRecentRequest,
30171 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30172 assertTrue(GrouperClientWs.mostRecentRequest,
30173 !GrouperClientWs.mostRecentRequest.contains("params"));
30174 assertTrue(GrouperClientWs.mostRecentRequest,
30175 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30176 assertTrue(GrouperClientWs.mostRecentRequest,
30177 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30178 assertFalse(GrouperClientWs.mostRecentRequest,
30179 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30180 assertTrue(GrouperClientWs.mostRecentRequest,
30181 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30182 assertTrue(GrouperClientWs.mostRecentRequest,
30183 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30184 assertTrue(GrouperClientWs.mostRecentRequest,
30185 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30186 assertTrue(GrouperClientWs.mostRecentRequest,
30187 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30188 assertTrue(GrouperClientWs.mostRecentRequest,
30189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30190 assertTrue(GrouperClientWs.mostRecentRequest,
30191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30192 assertTrue(GrouperClientWs.mostRecentRequest,
30193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30194 assertTrue(GrouperClientWs.mostRecentRequest,
30195 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30196 assertFalse(GrouperClientWs.mostRecentRequest,
30197 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30198 assertFalse(GrouperClientWs.mostRecentRequest,
30199 GrouperClientWs.mostRecentRequest.contains("theValue"));
30200 assertFalse(GrouperClientWs.mostRecentRequest,
30201 GrouperClientWs.mostRecentRequest.contains(">123<"));
30202 assertFalse(GrouperClientWs.mostRecentRequest,
30203 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30204 assertFalse(GrouperClientWs.mostRecentRequest,
30205 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30206 assertTrue(GrouperClientWs.mostRecentRequest,
30207 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30208 assertTrue(GrouperClientWs.mostRecentRequest,
30209 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30210 assertTrue(GrouperClientWs.mostRecentRequest,
30211 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30212 assertTrue(GrouperClientWs.mostRecentRequest,
30213 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30214 assertTrue(GrouperClientWs.mostRecentRequest,
30215 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30216 assertTrue(GrouperClientWs.mostRecentRequest,
30217 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30218
30219
30220
30221
30222
30223 baos = new ByteArrayOutputStream();
30224 System.setOut(new PrintStream(baos));
30225
30226 GrouperClient.main(GrouperClientUtils.splitTrim(
30227 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
30228 ,
30229 " "));
30230
30231 System.out.flush();
30232 output = new String(baos.toByteArray());
30233
30234 System.setOut(systemOut);
30235
30236 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30237
30238
30239
30240 pattern = Pattern
30241 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30242
30243 assertEquals(1, GrouperUtil.length(outputLines));
30244
30245 outputLine = outputLines[0];
30246
30247 matcher = pattern.matcher(outputLine);
30248
30249 assertTrue(outputLine, matcher.matches());
30250 assertEquals(outputLine, "0", matcher.group(1));
30251 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30252 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30253 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30254 assertEquals(outputLine, "assign", matcher.group(5));
30255 assertEquals(outputLine, "123", matcher.group(6));
30256 assertEquals(outputLine, "T", matcher.group(7));
30257 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30258
30259 assertTrue(GrouperClientWs.mostRecentRequest,
30260 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30261 assertTrue(GrouperClientWs.mostRecentRequest,
30262 !GrouperClientWs.mostRecentRequest.contains("actions"));
30263 assertTrue(GrouperClientWs.mostRecentRequest,
30264 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30265 assertTrue(GrouperClientWs.mostRecentRequest,
30266 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30267 assertTrue(GrouperClientWs.mostRecentRequest,
30268 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30269 assertTrue(GrouperClientWs.mostRecentRequest,
30270 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30271 assertTrue(GrouperClientWs.mostRecentRequest,
30272 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30273 assertTrue(GrouperClientWs.mostRecentRequest,
30274 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30275 assertTrue(GrouperClientWs.mostRecentRequest,
30276 !GrouperClientWs.mostRecentRequest.contains("params"));
30277 assertTrue(GrouperClientWs.mostRecentRequest,
30278 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30279 assertTrue(GrouperClientWs.mostRecentRequest,
30280 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30281 assertFalse(GrouperClientWs.mostRecentRequest,
30282 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30283 assertTrue(GrouperClientWs.mostRecentRequest,
30284 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30285 assertTrue(GrouperClientWs.mostRecentRequest,
30286 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30287 assertTrue(GrouperClientWs.mostRecentRequest,
30288 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30289 assertTrue(GrouperClientWs.mostRecentRequest,
30290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30291 assertTrue(GrouperClientWs.mostRecentRequest,
30292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30293 assertTrue(GrouperClientWs.mostRecentRequest,
30294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30295 assertTrue(GrouperClientWs.mostRecentRequest,
30296 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30297 assertTrue(GrouperClientWs.mostRecentRequest,
30298 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30299 assertFalse(GrouperClientWs.mostRecentRequest,
30300 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30301 assertFalse(GrouperClientWs.mostRecentRequest,
30302 GrouperClientWs.mostRecentRequest.contains("theValue"));
30303 assertFalse(GrouperClientWs.mostRecentRequest,
30304 GrouperClientWs.mostRecentRequest.contains(">123<"));
30305 assertFalse(GrouperClientWs.mostRecentRequest,
30306 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30307 assertFalse(GrouperClientWs.mostRecentRequest,
30308 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30309 assertTrue(GrouperClientWs.mostRecentRequest,
30310 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30311 assertTrue(GrouperClientWs.mostRecentRequest,
30312 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30313 assertTrue(GrouperClientWs.mostRecentRequest,
30314 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30315 assertTrue(GrouperClientWs.mostRecentRequest,
30316 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30317 assertTrue(GrouperClientWs.mostRecentRequest,
30318 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30319 assertTrue(GrouperClientWs.mostRecentRequest,
30320 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30321
30322
30323
30324
30325
30326
30327 baos = new ByteArrayOutputStream();
30328 System.setOut(new PrintStream(baos));
30329
30330 try {
30331 GrouperClient.main(GrouperClientUtils.splitTrim(
30332 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
30333 ,
30334 " "));
30335
30336 System.out.flush();
30337 output = new String(baos.toByteArray());
30338
30339 System.setOut(systemOut);
30340
30341 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30342
30343
30344
30345 pattern = Pattern
30346 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30347
30348 assertEquals(0, GrouperUtil.length(outputLines));
30349 fail("Shouldnt get here");
30350 } catch (Exception e) {
30351
30352 } finally {
30353
30354 System.setOut(systemOut);
30355
30356 }
30357
30358 assertTrue(GrouperClientWs.mostRecentRequest,
30359 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30360 assertTrue(GrouperClientWs.mostRecentRequest,
30361 !GrouperClientWs.mostRecentRequest.contains("actions"));
30362 assertTrue(GrouperClientWs.mostRecentRequest,
30363 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30364 assertTrue(GrouperClientWs.mostRecentRequest,
30365 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30366 assertTrue(GrouperClientWs.mostRecentRequest,
30367 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30368 assertTrue(GrouperClientWs.mostRecentRequest,
30369 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30370 assertTrue(GrouperClientWs.mostRecentRequest,
30371 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30372 assertTrue(GrouperClientWs.mostRecentRequest,
30373 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30374 assertTrue(GrouperClientWs.mostRecentRequest,
30375 !GrouperClientWs.mostRecentRequest.contains("params"));
30376 assertTrue(GrouperClientWs.mostRecentRequest,
30377 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30378 assertTrue(GrouperClientWs.mostRecentRequest,
30379 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30380 assertFalse(GrouperClientWs.mostRecentRequest,
30381 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30382 assertTrue(GrouperClientWs.mostRecentRequest,
30383 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30384 assertTrue(GrouperClientWs.mostRecentRequest,
30385 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30386 assertTrue(GrouperClientWs.mostRecentRequest,
30387 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30388 assertTrue(GrouperClientWs.mostRecentRequest,
30389 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30390 assertTrue(GrouperClientWs.mostRecentRequest,
30391 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30392 assertTrue(GrouperClientWs.mostRecentRequest,
30393 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30394 assertTrue(GrouperClientWs.mostRecentRequest,
30395 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30396 assertTrue(GrouperClientWs.mostRecentRequest,
30397 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30398 assertFalse(GrouperClientWs.mostRecentRequest,
30399 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30400 assertFalse(GrouperClientWs.mostRecentRequest,
30401 GrouperClientWs.mostRecentRequest.contains("theValue"));
30402 assertFalse(GrouperClientWs.mostRecentRequest,
30403 GrouperClientWs.mostRecentRequest.contains(">123<"));
30404 assertFalse(GrouperClientWs.mostRecentRequest,
30405 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30406 assertFalse(GrouperClientWs.mostRecentRequest,
30407 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30408 assertTrue(GrouperClientWs.mostRecentRequest,
30409 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30410 assertTrue(GrouperClientWs.mostRecentRequest,
30411 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30412 assertTrue(GrouperClientWs.mostRecentRequest,
30413 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30414 assertTrue(GrouperClientWs.mostRecentRequest,
30415 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30416 assertTrue(GrouperClientWs.mostRecentRequest,
30417 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30418 assertTrue(GrouperClientWs.mostRecentRequest,
30419 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30420
30421
30422
30423
30424
30425 baos = new ByteArrayOutputStream();
30426 System.setOut(new PrintStream(baos));
30427
30428 GrouperClient.main(GrouperClientUtils.splitTrim(
30429 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
30430 ,
30431 " "));
30432
30433 System.out.flush();
30434 output = new String(baos.toByteArray());
30435
30436 System.setOut(systemOut);
30437
30438 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30439
30440
30441
30442 pattern = Pattern
30443 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30444
30445 assertEquals(1, GrouperUtil.length(outputLines));
30446
30447 outputLine = outputLines[0];
30448
30449 matcher = pattern.matcher(outputLine);
30450
30451 assertTrue(outputLine, matcher.matches());
30452 assertEquals(outputLine, "0", matcher.group(1));
30453 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30454 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30455 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30456 assertEquals(outputLine, "assign", matcher.group(5));
30457 assertEquals(outputLine, "123", matcher.group(6));
30458 assertEquals(outputLine, "T", matcher.group(7));
30459 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30460
30461 assertTrue(GrouperClientWs.mostRecentRequest,
30462 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30463 assertTrue(GrouperClientWs.mostRecentRequest,
30464 !GrouperClientWs.mostRecentRequest.contains("actions"));
30465 assertTrue(GrouperClientWs.mostRecentRequest,
30466 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30467 assertTrue(GrouperClientWs.mostRecentRequest,
30468 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30469 assertTrue(GrouperClientWs.mostRecentRequest,
30470 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30471 assertTrue(GrouperClientWs.mostRecentRequest,
30472 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30473 assertTrue(GrouperClientWs.mostRecentRequest,
30474 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30475 assertTrue(GrouperClientWs.mostRecentRequest,
30476 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30477 assertTrue(GrouperClientWs.mostRecentRequest,
30478 !GrouperClientWs.mostRecentRequest.contains("params"));
30479 assertTrue(GrouperClientWs.mostRecentRequest,
30480 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30481 assertTrue(GrouperClientWs.mostRecentRequest,
30482 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30483 assertFalse(GrouperClientWs.mostRecentRequest,
30484 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30485 assertFalse(GrouperClientWs.mostRecentRequest,
30486 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30487 assertTrue(GrouperClientWs.mostRecentRequest,
30488 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30489 assertTrue(GrouperClientWs.mostRecentRequest,
30490 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30491 assertTrue(GrouperClientWs.mostRecentRequest,
30492 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30493 assertTrue(GrouperClientWs.mostRecentRequest,
30494 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30495 assertTrue(GrouperClientWs.mostRecentRequest,
30496 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30497 assertTrue(GrouperClientWs.mostRecentRequest,
30498 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30499 assertTrue(GrouperClientWs.mostRecentRequest,
30500 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30501 assertFalse(GrouperClientWs.mostRecentRequest,
30502 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30503 assertFalse(GrouperClientWs.mostRecentRequest,
30504 GrouperClientWs.mostRecentRequest.contains("theValue"));
30505 assertFalse(GrouperClientWs.mostRecentRequest,
30506 GrouperClientWs.mostRecentRequest.contains(">123<"));
30507 assertFalse(GrouperClientWs.mostRecentRequest,
30508 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30509 assertFalse(GrouperClientWs.mostRecentRequest,
30510 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30511 assertTrue(GrouperClientWs.mostRecentRequest,
30512 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30513 assertTrue(GrouperClientWs.mostRecentRequest,
30514 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30515 assertTrue(GrouperClientWs.mostRecentRequest,
30516 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30517 assertTrue(GrouperClientWs.mostRecentRequest,
30518 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30519
30520
30521
30522
30523
30524
30525 baos = new ByteArrayOutputStream();
30526 System.setOut(new PrintStream(baos));
30527
30528 try {
30529 GrouperClient.main(GrouperClientUtils.splitTrim(
30530 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
30531 ,
30532 " "));
30533
30534 System.out.flush();
30535 output = new String(baos.toByteArray());
30536
30537 System.setOut(systemOut);
30538
30539 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30540
30541
30542
30543 pattern = Pattern
30544 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30545
30546 assertEquals(0, GrouperUtil.length(outputLines));
30547 fail("Shouldnt get here");
30548
30549 } catch (Exception e) {
30550
30551 } finally {
30552
30553 System.setOut(systemOut);
30554
30555 }
30556
30557 assertTrue(GrouperClientWs.mostRecentRequest,
30558 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30559 assertTrue(GrouperClientWs.mostRecentRequest,
30560 !GrouperClientWs.mostRecentRequest.contains("actions"));
30561 assertTrue(GrouperClientWs.mostRecentRequest,
30562 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30563 assertTrue(GrouperClientWs.mostRecentRequest,
30564 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30565 assertTrue(GrouperClientWs.mostRecentRequest,
30566 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30567 assertTrue(GrouperClientWs.mostRecentRequest,
30568 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30569 assertTrue(GrouperClientWs.mostRecentRequest,
30570 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30571 assertTrue(GrouperClientWs.mostRecentRequest,
30572 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30573 assertTrue(GrouperClientWs.mostRecentRequest,
30574 !GrouperClientWs.mostRecentRequest.contains("params"));
30575 assertTrue(GrouperClientWs.mostRecentRequest,
30576 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30577 assertTrue(GrouperClientWs.mostRecentRequest,
30578 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30579 assertFalse(GrouperClientWs.mostRecentRequest,
30580 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30581 assertFalse(GrouperClientWs.mostRecentRequest,
30582 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30583 assertTrue(GrouperClientWs.mostRecentRequest,
30584 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30585 assertTrue(GrouperClientWs.mostRecentRequest,
30586 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30587 assertTrue(GrouperClientWs.mostRecentRequest,
30588 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30589 assertTrue(GrouperClientWs.mostRecentRequest,
30590 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30591 assertTrue(GrouperClientWs.mostRecentRequest,
30592 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30593 assertTrue(GrouperClientWs.mostRecentRequest,
30594 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30595 assertTrue(GrouperClientWs.mostRecentRequest,
30596 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30597 assertFalse(GrouperClientWs.mostRecentRequest,
30598 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30599 assertFalse(GrouperClientWs.mostRecentRequest,
30600 GrouperClientWs.mostRecentRequest.contains("theValue"));
30601 assertFalse(GrouperClientWs.mostRecentRequest,
30602 GrouperClientWs.mostRecentRequest.contains(">123<"));
30603 assertFalse(GrouperClientWs.mostRecentRequest,
30604 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30605 assertFalse(GrouperClientWs.mostRecentRequest,
30606 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30607 assertTrue(GrouperClientWs.mostRecentRequest,
30608 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30609 assertTrue(GrouperClientWs.mostRecentRequest,
30610 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30611 assertTrue(GrouperClientWs.mostRecentRequest,
30612 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30613 assertTrue(GrouperClientWs.mostRecentRequest,
30614 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30615
30616
30617
30618
30619
30620 baos = new ByteArrayOutputStream();
30621 System.setOut(new PrintStream(baos));
30622
30623 GrouperClient.main(GrouperClientUtils.splitTrim(
30624 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
30625 ,
30626 " "));
30627
30628 System.out.flush();
30629 output = new String(baos.toByteArray());
30630
30631 System.setOut(systemOut);
30632
30633 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30634
30635
30636
30637 pattern = Pattern
30638 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30639
30640 assertEquals(1, GrouperUtil.length(outputLines));
30641
30642 outputLine = outputLines[0];
30643
30644 matcher = pattern.matcher(outputLine);
30645
30646 assertTrue(outputLine, matcher.matches());
30647 assertEquals(outputLine, "0", matcher.group(1));
30648 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30649 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30650 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30651 assertEquals(outputLine, "assign", matcher.group(5));
30652 assertEquals(outputLine, "123", matcher.group(6));
30653 assertEquals(outputLine, "T", matcher.group(7));
30654 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30655
30656 assertTrue(GrouperClientWs.mostRecentRequest,
30657 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30658 assertTrue(GrouperClientWs.mostRecentRequest,
30659 !GrouperClientWs.mostRecentRequest.contains("actions"));
30660 assertTrue(GrouperClientWs.mostRecentRequest,
30661 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30662 assertTrue(GrouperClientWs.mostRecentRequest,
30663 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30664 assertTrue(GrouperClientWs.mostRecentRequest,
30665 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30666 assertTrue(GrouperClientWs.mostRecentRequest,
30667 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30668 assertTrue(GrouperClientWs.mostRecentRequest,
30669 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30670 assertTrue(GrouperClientWs.mostRecentRequest,
30671 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30672 assertTrue(GrouperClientWs.mostRecentRequest,
30673 !GrouperClientWs.mostRecentRequest.contains("params"));
30674 assertTrue(GrouperClientWs.mostRecentRequest,
30675 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30676 assertTrue(GrouperClientWs.mostRecentRequest,
30677 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30678 assertFalse(GrouperClientWs.mostRecentRequest,
30679 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30680 assertTrue(GrouperClientWs.mostRecentRequest,
30681 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30682 assertTrue(GrouperClientWs.mostRecentRequest,
30683 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30684 assertTrue(GrouperClientWs.mostRecentRequest,
30685 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30686 assertTrue(GrouperClientWs.mostRecentRequest,
30687 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30688 assertTrue(GrouperClientWs.mostRecentRequest,
30689 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30690 assertTrue(GrouperClientWs.mostRecentRequest,
30691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30692 assertTrue(GrouperClientWs.mostRecentRequest,
30693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30694 assertTrue(GrouperClientWs.mostRecentRequest,
30695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30696 assertFalse(GrouperClientWs.mostRecentRequest,
30697 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30698 assertFalse(GrouperClientWs.mostRecentRequest,
30699 GrouperClientWs.mostRecentRequest.contains("theValue"));
30700 assertFalse(GrouperClientWs.mostRecentRequest,
30701 GrouperClientWs.mostRecentRequest.contains(">123<"));
30702 assertFalse(GrouperClientWs.mostRecentRequest,
30703 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30704 assertFalse(GrouperClientWs.mostRecentRequest,
30705 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30706 assertTrue(GrouperClientWs.mostRecentRequest,
30707 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30708 assertTrue(GrouperClientWs.mostRecentRequest,
30709 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30710 assertTrue(GrouperClientWs.mostRecentRequest,
30711 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30712 assertTrue(GrouperClientWs.mostRecentRequest,
30713 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30714
30715
30716
30717
30718
30719
30720 baos = new ByteArrayOutputStream();
30721 System.setOut(new PrintStream(baos));
30722
30723 try {
30724 GrouperClient.main(GrouperClientUtils.splitTrim(
30725 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
30726 ,
30727 " "));
30728
30729 System.out.flush();
30730 output = new String(baos.toByteArray());
30731
30732 System.setOut(systemOut);
30733
30734 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30735
30736
30737
30738 pattern = Pattern
30739 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30740
30741 assertEquals(1, GrouperUtil.length(outputLines));
30742 fail("Shouldnt get here");
30743 } catch (Exception e) {
30744
30745 } finally {
30746
30747 System.setOut(systemOut);
30748
30749 }
30750
30751 assertTrue(GrouperClientWs.mostRecentRequest,
30752 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30753 assertTrue(GrouperClientWs.mostRecentRequest,
30754 !GrouperClientWs.mostRecentRequest.contains("actions"));
30755 assertTrue(GrouperClientWs.mostRecentRequest,
30756 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30757 assertTrue(GrouperClientWs.mostRecentRequest,
30758 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30759 assertTrue(GrouperClientWs.mostRecentRequest,
30760 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30761 assertTrue(GrouperClientWs.mostRecentRequest,
30762 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30763 assertTrue(GrouperClientWs.mostRecentRequest,
30764 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30765 assertTrue(GrouperClientWs.mostRecentRequest,
30766 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30767 assertTrue(GrouperClientWs.mostRecentRequest,
30768 !GrouperClientWs.mostRecentRequest.contains("params"));
30769 assertTrue(GrouperClientWs.mostRecentRequest,
30770 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30771 assertTrue(GrouperClientWs.mostRecentRequest,
30772 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30773 assertFalse(GrouperClientWs.mostRecentRequest,
30774 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30775 assertTrue(GrouperClientWs.mostRecentRequest,
30776 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30777 assertTrue(GrouperClientWs.mostRecentRequest,
30778 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30779 assertTrue(GrouperClientWs.mostRecentRequest,
30780 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30781 assertTrue(GrouperClientWs.mostRecentRequest,
30782 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30783 assertTrue(GrouperClientWs.mostRecentRequest,
30784 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30785 assertTrue(GrouperClientWs.mostRecentRequest,
30786 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30787 assertTrue(GrouperClientWs.mostRecentRequest,
30788 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30789 assertTrue(GrouperClientWs.mostRecentRequest,
30790 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30791 assertFalse(GrouperClientWs.mostRecentRequest,
30792 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30793 assertFalse(GrouperClientWs.mostRecentRequest,
30794 GrouperClientWs.mostRecentRequest.contains("theValue"));
30795 assertFalse(GrouperClientWs.mostRecentRequest,
30796 GrouperClientWs.mostRecentRequest.contains(">123<"));
30797 assertFalse(GrouperClientWs.mostRecentRequest,
30798 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30799 assertFalse(GrouperClientWs.mostRecentRequest,
30800 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30801 assertTrue(GrouperClientWs.mostRecentRequest,
30802 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30803 assertTrue(GrouperClientWs.mostRecentRequest,
30804 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30805 assertTrue(GrouperClientWs.mostRecentRequest,
30806 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30807 assertTrue(GrouperClientWs.mostRecentRequest,
30808 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30809
30810
30811
30812
30813
30814 baos = new ByteArrayOutputStream();
30815 System.setOut(new PrintStream(baos));
30816
30817 GrouperClient.main(GrouperClientUtils.splitTrim(
30818 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
30819 + " --assignAssignOwnerActions=assign",
30820 " "));
30821
30822 System.out.flush();
30823 output = new String(baos.toByteArray());
30824
30825 System.setOut(systemOut);
30826
30827 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30828
30829
30830
30831 pattern = Pattern
30832 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30833
30834 assertEquals(1, GrouperUtil.length(outputLines));
30835
30836 outputLine = outputLines[0];
30837
30838 matcher = pattern.matcher(outputLine);
30839
30840 assertTrue(outputLine, matcher.matches());
30841 assertEquals(outputLine, "0", matcher.group(1));
30842 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30843 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30844 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30845 assertEquals(outputLine, "assign", matcher.group(5));
30846 assertEquals(outputLine, "123", matcher.group(6));
30847 assertEquals(outputLine, "T", matcher.group(7));
30848 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30849
30850 assertTrue(GrouperClientWs.mostRecentRequest,
30851 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30852 assertTrue(GrouperClientWs.mostRecentRequest,
30853 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
30854 assertTrue(GrouperClientWs.mostRecentRequest,
30855 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30856 assertTrue(GrouperClientWs.mostRecentRequest,
30857 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30858 assertTrue(GrouperClientWs.mostRecentRequest,
30859 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30860 assertTrue(GrouperClientWs.mostRecentRequest,
30861 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30862 assertTrue(GrouperClientWs.mostRecentRequest,
30863 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30864 assertTrue(GrouperClientWs.mostRecentRequest,
30865 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30866 assertTrue(GrouperClientWs.mostRecentRequest,
30867 !GrouperClientWs.mostRecentRequest.contains("params"));
30868 assertTrue(GrouperClientWs.mostRecentRequest,
30869 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30870 assertTrue(GrouperClientWs.mostRecentRequest,
30871 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30872 assertFalse(GrouperClientWs.mostRecentRequest,
30873 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30874 assertTrue(GrouperClientWs.mostRecentRequest,
30875 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30876 assertTrue(GrouperClientWs.mostRecentRequest,
30877 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30878 assertTrue(GrouperClientWs.mostRecentRequest,
30879 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30880 assertTrue(GrouperClientWs.mostRecentRequest,
30881 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30882 assertTrue(GrouperClientWs.mostRecentRequest,
30883 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30884 assertTrue(GrouperClientWs.mostRecentRequest,
30885 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30886 assertTrue(GrouperClientWs.mostRecentRequest,
30887 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30888 assertTrue(GrouperClientWs.mostRecentRequest,
30889 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30890 assertFalse(GrouperClientWs.mostRecentRequest,
30891 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30892 assertFalse(GrouperClientWs.mostRecentRequest,
30893 GrouperClientWs.mostRecentRequest.contains("theValue"));
30894 assertFalse(GrouperClientWs.mostRecentRequest,
30895 GrouperClientWs.mostRecentRequest.contains(">123<"));
30896 assertFalse(GrouperClientWs.mostRecentRequest,
30897 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30898 assertFalse(GrouperClientWs.mostRecentRequest,
30899 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30900 assertTrue(GrouperClientWs.mostRecentRequest,
30901 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30902 assertTrue(GrouperClientWs.mostRecentRequest,
30903 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30904 assertTrue(GrouperClientWs.mostRecentRequest,
30905 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30906 assertTrue(GrouperClientWs.mostRecentRequest,
30907 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
30908
30909
30910
30911
30912
30913 baos = new ByteArrayOutputStream();
30914 System.setOut(new PrintStream(baos));
30915
30916 GrouperClient.main(GrouperClientUtils.splitTrim(
30917 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
30918 + " --assignAssignOwnerActions=assign2",
30919 " "));
30920
30921 System.out.flush();
30922 output = new String(baos.toByteArray());
30923
30924 System.setOut(systemOut);
30925
30926 outputLines = GrouperClientUtils.splitTrim(output, "\n");
30927
30928
30929
30930 pattern = Pattern
30931 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30932
30933 assertEquals(0, GrouperUtil.length(outputLines));
30934
30935 assertTrue(GrouperClientWs.mostRecentRequest,
30936 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30937 assertTrue(GrouperClientWs.mostRecentRequest,
30938 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
30939 assertTrue(GrouperClientWs.mostRecentRequest,
30940 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30941 assertTrue(GrouperClientWs.mostRecentRequest,
30942 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30943 assertTrue(GrouperClientWs.mostRecentRequest,
30944 !GrouperClientWs.mostRecentRequest.contains("enabled"));
30945 assertTrue(GrouperClientWs.mostRecentRequest,
30946 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30947 assertTrue(GrouperClientWs.mostRecentRequest,
30948 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30949 assertTrue(GrouperClientWs.mostRecentRequest,
30950 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30951 assertTrue(GrouperClientWs.mostRecentRequest,
30952 !GrouperClientWs.mostRecentRequest.contains("params"));
30953 assertTrue(GrouperClientWs.mostRecentRequest,
30954 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30955 assertTrue(GrouperClientWs.mostRecentRequest,
30956 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30957 assertFalse(GrouperClientWs.mostRecentRequest,
30958 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30959 assertTrue(GrouperClientWs.mostRecentRequest,
30960 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30961 assertTrue(GrouperClientWs.mostRecentRequest,
30962 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30963 assertTrue(GrouperClientWs.mostRecentRequest,
30964 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30965 assertTrue(GrouperClientWs.mostRecentRequest,
30966 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30967 assertTrue(GrouperClientWs.mostRecentRequest,
30968 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30969 assertTrue(GrouperClientWs.mostRecentRequest,
30970 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30971 assertTrue(GrouperClientWs.mostRecentRequest,
30972 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30973 assertTrue(GrouperClientWs.mostRecentRequest,
30974 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30975 assertFalse(GrouperClientWs.mostRecentRequest,
30976 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30977 assertFalse(GrouperClientWs.mostRecentRequest,
30978 GrouperClientWs.mostRecentRequest.contains("theValue"));
30979 assertFalse(GrouperClientWs.mostRecentRequest,
30980 GrouperClientWs.mostRecentRequest.contains(">123<"));
30981 assertFalse(GrouperClientWs.mostRecentRequest,
30982 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30983 assertFalse(GrouperClientWs.mostRecentRequest,
30984 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30985 assertTrue(GrouperClientWs.mostRecentRequest,
30986 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30987 assertTrue(GrouperClientWs.mostRecentRequest,
30988 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30989 assertTrue(GrouperClientWs.mostRecentRequest,
30990 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30991 assertTrue(GrouperClientWs.mostRecentRequest,
30992 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
30993
30994
30995
30996
30997
30998
30999 baos = new ByteArrayOutputStream();
31000 System.setOut(new PrintStream(baos));
31001
31002 GrouperClient.main(GrouperClientUtils.splitTrim(
31003 "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --ownerAttributeDefNames=" + ownerAttributeDef.getName()
31004 ,
31005 " "));
31006
31007 System.out.flush();
31008 output = new String(baos.toByteArray());
31009
31010 System.setOut(systemOut);
31011
31012 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31013
31014
31015
31016 pattern = Pattern
31017 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31018
31019 assertEquals(1, GrouperUtil.length(outputLines));
31020
31021 outputLine = outputLines[0];
31022
31023 matcher = pattern.matcher(outputLine);
31024
31025 assertTrue(outputLine, matcher.matches());
31026 assertEquals(outputLine, "0", matcher.group(1));
31027 assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
31028 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31029 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31030 assertEquals(outputLine, "assign", matcher.group(5));
31031 assertEquals(outputLine, "123", matcher.group(6));
31032 assertEquals(outputLine, "T", matcher.group(7));
31033 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31034
31035 assertTrue(GrouperClientWs.mostRecentRequest,
31036 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31037 assertTrue(GrouperClientWs.mostRecentRequest,
31038 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
31039 assertTrue(GrouperClientWs.mostRecentRequest,
31040 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31041 assertTrue(GrouperClientWs.mostRecentRequest,
31042 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31043 assertTrue(GrouperClientWs.mostRecentRequest,
31044 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31045 assertTrue(GrouperClientWs.mostRecentRequest,
31046 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31047 assertTrue(GrouperClientWs.mostRecentRequest,
31048 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31049 assertTrue(GrouperClientWs.mostRecentRequest,
31050 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31051 assertTrue(GrouperClientWs.mostRecentRequest,
31052 !GrouperClientWs.mostRecentRequest.contains("params"));
31053 assertTrue(GrouperClientWs.mostRecentRequest,
31054 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31055 assertTrue(GrouperClientWs.mostRecentRequest,
31056 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31057 assertFalse(GrouperClientWs.mostRecentRequest,
31058 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
31059 assertFalse(GrouperClientWs.mostRecentRequest,
31060 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31061 assertTrue(GrouperClientWs.mostRecentRequest,
31062 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31063 assertTrue(GrouperClientWs.mostRecentRequest,
31064 GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31065 assertTrue(GrouperClientWs.mostRecentRequest,
31066 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31067 assertTrue(GrouperClientWs.mostRecentRequest,
31068 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31069 assertTrue(GrouperClientWs.mostRecentRequest,
31070 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31071 assertTrue(GrouperClientWs.mostRecentRequest,
31072 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31073 assertTrue(GrouperClientWs.mostRecentRequest,
31074 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31075 assertFalse(GrouperClientWs.mostRecentRequest,
31076 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31077 assertFalse(GrouperClientWs.mostRecentRequest,
31078 GrouperClientWs.mostRecentRequest.contains("theValue"));
31079 assertFalse(GrouperClientWs.mostRecentRequest,
31080 GrouperClientWs.mostRecentRequest.contains(">123<"));
31081 assertFalse(GrouperClientWs.mostRecentRequest,
31082 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31083 assertFalse(GrouperClientWs.mostRecentRequest,
31084 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31085 assertTrue(GrouperClientWs.mostRecentRequest,
31086 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31087 assertTrue(GrouperClientWs.mostRecentRequest,
31088 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31089 assertTrue(GrouperClientWs.mostRecentRequest,
31090 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31091 assertTrue(GrouperClientWs.mostRecentRequest,
31092 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
31093
31094
31095 } finally {
31096 System.setOut(systemOut);
31097 }
31098
31099 }
31100
31101
31102
31103
31104 public void testGetAttributeAssignsMembershipExtraFeatures() throws Exception {
31105
31106 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
31107 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
31108
31109 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
31110
31111 attributeDef.setValueType(AttributeDefValueType.string);
31112 attributeDef.setAssignToGroup(false);
31113 attributeDef.setAssignToImmMembership(true);
31114 attributeDef.store();
31115
31116 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
31117
31118 attributeDef2.setAssignToGroup(false);
31119 attributeDef2.setAssignToImmMembershipAssn(true);
31120 attributeDef2.setValueType(AttributeDefValueType.integer);
31121 attributeDef2.store();
31122
31123 Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
31124 .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
31125 .assignDescription("description").save();
31126
31127 group.addMember(SubjectTestHelper.SUBJ1);
31128
31129 Membership membership = MembershipFinder.findImmediateMembership(GrouperSession.staticGrouperSession(),
31130 group, SubjectTestHelper.SUBJ1, true);
31131
31132 AttributeAssignResult attributeAssignResult = membership.getAttributeDelegate().assignAttribute(attributeDefName);
31133 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
31134 attributeAssign.getValueDelegate().assignValue("abc");
31135
31136 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
31137 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
31138 attributeAssign2.getValueDelegate().assignValue("123");
31139
31140 PrintStream systemOut = System.out;
31141
31142 ByteArrayOutputStream baos = new ByteArrayOutputStream();
31143 System.setOut(new PrintStream(baos));
31144
31145 try {
31146
31147 GrouperClient.main(GrouperClientUtils.splitTrim(
31148 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem " +
31149 "--attributeDefNames=test:testAttributeAssignDefNameDef " +
31150 "--attributeDefValueType=string --value=abc",
31151 " "));
31152 System.out.flush();
31153 String output = new String(baos.toByteArray());
31154
31155 System.setOut(systemOut);
31156
31157 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
31158
31159
31160
31161 Pattern pattern = Pattern
31162 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31163
31164 assertEquals(1, GrouperUtil.length(outputLines));
31165 String outputLine = outputLines[0];
31166
31167 Matcher matcher = pattern.matcher(outputLines[0]);
31168
31169 assertTrue(outputLine, matcher.matches());
31170 assertEquals(outputLine, "0", matcher.group(1));
31171 assertEquals(outputLine, "imm_mem", matcher.group(2));
31172 assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
31173 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
31174 assertEquals(outputLine, "assign", matcher.group(5));
31175 assertEquals(outputLine, "abc", matcher.group(6));
31176 assertEquals(outputLine, "T", matcher.group(7));
31177 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
31178
31179 assertTrue(GrouperClientWs.mostRecentRequest,
31180 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31181 assertTrue(GrouperClientWs.mostRecentRequest,
31182 !GrouperClientWs.mostRecentRequest.contains("actions"));
31183 assertTrue(GrouperClientWs.mostRecentRequest,
31184 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31185 assertTrue(GrouperClientWs.mostRecentRequest,
31186 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31187 assertTrue(GrouperClientWs.mostRecentRequest,
31188 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31189 assertTrue(GrouperClientWs.mostRecentRequest,
31190 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31191 assertTrue(GrouperClientWs.mostRecentRequest,
31192 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31193 assertTrue(GrouperClientWs.mostRecentRequest,
31194 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31195 assertTrue(GrouperClientWs.mostRecentRequest,
31196 !GrouperClientWs.mostRecentRequest.contains("params"));
31197 assertTrue(GrouperClientWs.mostRecentRequest,
31198 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31199 assertTrue(GrouperClientWs.mostRecentRequest,
31200 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31201 assertTrue(GrouperClientWs.mostRecentRequest,
31202 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
31203 assertTrue(GrouperClientWs.mostRecentRequest,
31204 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31205 assertTrue(GrouperClientWs.mostRecentRequest,
31206 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31207 assertTrue(GrouperClientWs.mostRecentRequest,
31208 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31209 assertTrue(GrouperClientWs.mostRecentRequest,
31210 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31211 assertTrue(GrouperClientWs.mostRecentRequest,
31212 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31213 assertTrue(GrouperClientWs.mostRecentRequest,
31214 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31215 assertTrue(GrouperClientWs.mostRecentRequest,
31216 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31217 assertTrue(GrouperClientWs.mostRecentRequest,
31218 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31219 assertTrue(GrouperClientWs.mostRecentRequest,
31220 GrouperClientWs.mostRecentRequest.contains("theValue"));
31221 assertTrue(GrouperClientWs.mostRecentRequest,
31222 GrouperClientWs.mostRecentRequest.contains("abc"));
31223 assertTrue(GrouperClientWs.mostRecentRequest,
31224 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31225 assertTrue(GrouperClientWs.mostRecentRequest,
31226 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31227 assertTrue(GrouperClientWs.mostRecentRequest,
31228 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31229 assertTrue(GrouperClientWs.mostRecentRequest,
31230 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31231 assertTrue(GrouperClientWs.mostRecentRequest,
31232 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31233 assertTrue(GrouperClientWs.mostRecentRequest,
31234 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31235 assertTrue(GrouperClientWs.mostRecentRequest,
31236 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31237 assertTrue(GrouperClientWs.mostRecentRequest,
31238 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31239
31240
31241
31242
31243 baos = new ByteArrayOutputStream();
31244 System.setOut(new PrintStream(baos));
31245
31246 GrouperClient.main(GrouperClientUtils.splitTrim(
31247 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=" + attributeDef.getId() +
31248 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
31249 "--attributeDefValueType=string --value=123",
31250 " "));
31251
31252
31253 System.out.flush();
31254 output = new String(baos.toByteArray());
31255
31256 System.setOut(systemOut);
31257
31258 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31259
31260 assertEquals(0, GrouperUtil.length(outputLines));
31261
31262
31263
31264
31265 assertTrue(GrouperClientWs.mostRecentRequest,
31266 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31267 assertTrue(GrouperClientWs.mostRecentRequest,
31268 !GrouperClientWs.mostRecentRequest.contains("actions"));
31269 assertTrue(GrouperClientWs.mostRecentRequest,
31270 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31271 assertTrue(GrouperClientWs.mostRecentRequest,
31272 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31273 assertTrue(GrouperClientWs.mostRecentRequest,
31274 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31275 assertTrue(GrouperClientWs.mostRecentRequest,
31276 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31277 assertTrue(GrouperClientWs.mostRecentRequest,
31278 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31279 assertTrue(GrouperClientWs.mostRecentRequest,
31280 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31281 assertTrue(GrouperClientWs.mostRecentRequest,
31282 !GrouperClientWs.mostRecentRequest.contains("params"));
31283 assertTrue(GrouperClientWs.mostRecentRequest,
31284 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31285 assertTrue(GrouperClientWs.mostRecentRequest,
31286 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31287 assertTrue(GrouperClientWs.mostRecentRequest,
31288 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
31289 assertTrue(GrouperClientWs.mostRecentRequest,
31290 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31291 assertTrue(GrouperClientWs.mostRecentRequest,
31292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31293 assertTrue(GrouperClientWs.mostRecentRequest,
31294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31295 assertTrue(GrouperClientWs.mostRecentRequest,
31296 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31297 assertTrue(GrouperClientWs.mostRecentRequest,
31298 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31299 assertTrue(GrouperClientWs.mostRecentRequest,
31300 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31301 assertTrue(GrouperClientWs.mostRecentRequest,
31302 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31303 assertTrue(GrouperClientWs.mostRecentRequest,
31304 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31305 assertTrue(GrouperClientWs.mostRecentRequest,
31306 GrouperClientWs.mostRecentRequest.contains("theValue"));
31307 assertTrue(GrouperClientWs.mostRecentRequest,
31308 GrouperClientWs.mostRecentRequest.contains(">123<"));
31309 assertTrue(GrouperClientWs.mostRecentRequest,
31310 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31311 assertTrue(GrouperClientWs.mostRecentRequest,
31312 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31313 assertTrue(GrouperClientWs.mostRecentRequest,
31314 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31315 assertTrue(GrouperClientWs.mostRecentRequest,
31316 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31317 assertTrue(GrouperClientWs.mostRecentRequest,
31318 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31319 assertTrue(GrouperClientWs.mostRecentRequest,
31320 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31321 assertTrue(GrouperClientWs.mostRecentRequest,
31322 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31323 assertTrue(GrouperClientWs.mostRecentRequest,
31324 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31325
31326
31327
31328
31329
31330 baos = new ByteArrayOutputStream();
31331 System.setOut(new PrintStream(baos));
31332
31333 try {
31334 GrouperClient.main(GrouperClientUtils.splitTrim(
31335 " --operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=123" + attributeDef.getId() +
31336 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
31337 "--attributeDefValueType=string --value=123",
31338 " "));
31339 fail("Shouldnt get here");
31340 } catch (GcWebServiceError gwse) {
31341
31342 }
31343
31344
31345
31346
31347 baos = new ByteArrayOutputStream();
31348 System.setOut(new PrintStream(baos));
31349
31350 GrouperClient.main(GrouperClientUtils.splitTrim(
31351 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=" + attributeDef.getId() +
31352 " --attributeDefValueType=string --value=abc --attributeDefType=attr",
31353 " "));
31354
31355
31356 System.out.flush();
31357 output = new String(baos.toByteArray());
31358
31359 System.setOut(systemOut);
31360
31361 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31362
31363
31364
31365 pattern = Pattern
31366 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31367
31368 assertEquals(1, GrouperUtil.length(outputLines));
31369 outputLine = outputLines[0];
31370
31371 matcher = pattern.matcher(outputLines[0]);
31372
31373 assertTrue(outputLine, matcher.matches());
31374 assertEquals(outputLine, "0", matcher.group(1));
31375 assertEquals(outputLine, "imm_mem", matcher.group(2));
31376 assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
31377 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
31378 assertEquals(outputLine, "assign", matcher.group(5));
31379 assertEquals(outputLine, "abc", matcher.group(6));
31380 assertEquals(outputLine, "T", matcher.group(7));
31381 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
31382
31383 assertTrue(GrouperClientWs.mostRecentRequest,
31384 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31385 assertTrue(GrouperClientWs.mostRecentRequest,
31386 !GrouperClientWs.mostRecentRequest.contains("actions"));
31387 assertTrue(GrouperClientWs.mostRecentRequest,
31388 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31389 assertTrue(GrouperClientWs.mostRecentRequest,
31390 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31391 assertTrue(GrouperClientWs.mostRecentRequest,
31392 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31393 assertTrue(GrouperClientWs.mostRecentRequest,
31394 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31395 assertTrue(GrouperClientWs.mostRecentRequest,
31396 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31397 assertTrue(GrouperClientWs.mostRecentRequest,
31398 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31399 assertTrue(GrouperClientWs.mostRecentRequest,
31400 !GrouperClientWs.mostRecentRequest.contains("params"));
31401 assertTrue(GrouperClientWs.mostRecentRequest,
31402 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31403 assertTrue(GrouperClientWs.mostRecentRequest,
31404 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31405 assertTrue(GrouperClientWs.mostRecentRequest,
31406 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31407 assertTrue(GrouperClientWs.mostRecentRequest,
31408 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31409 assertTrue(GrouperClientWs.mostRecentRequest,
31410 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31411 assertTrue(GrouperClientWs.mostRecentRequest,
31412 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31413 assertTrue(GrouperClientWs.mostRecentRequest,
31414 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31415 assertTrue(GrouperClientWs.mostRecentRequest,
31416 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31417 assertTrue(GrouperClientWs.mostRecentRequest,
31418 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31419 assertTrue(GrouperClientWs.mostRecentRequest,
31420 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31421 assertTrue(GrouperClientWs.mostRecentRequest,
31422 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31423 assertTrue(GrouperClientWs.mostRecentRequest,
31424 GrouperClientWs.mostRecentRequest.contains("theValue"));
31425 assertTrue(GrouperClientWs.mostRecentRequest,
31426 GrouperClientWs.mostRecentRequest.contains("abc"));
31427 assertTrue(GrouperClientWs.mostRecentRequest,
31428 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31429 assertTrue(GrouperClientWs.mostRecentRequest,
31430 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31431 assertTrue(GrouperClientWs.mostRecentRequest,
31432 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31433 assertTrue(GrouperClientWs.mostRecentRequest,
31434 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31435 assertTrue(GrouperClientWs.mostRecentRequest,
31436 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31437 assertTrue(GrouperClientWs.mostRecentRequest,
31438 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31439 assertTrue(GrouperClientWs.mostRecentRequest,
31440 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31441 assertTrue(GrouperClientWs.mostRecentRequest,
31442 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31443
31444
31445
31446
31447 baos = new ByteArrayOutputStream();
31448 System.setOut(new PrintStream(baos));
31449
31450 GrouperClient.main(GrouperClientUtils.splitTrim(
31451 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=" + attributeDef.getId() +
31452 " --attributeDefValueType=string --value=abc --attributeDefType=limit",
31453 " "));
31454
31455 System.out.flush();
31456 output = new String(baos.toByteArray());
31457
31458 System.setOut(systemOut);
31459
31460 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31461
31462
31463
31464 pattern = Pattern
31465 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31466
31467 assertEquals(0, GrouperUtil.length(outputLines));
31468
31469 assertTrue(GrouperClientWs.mostRecentRequest,
31470 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31471 assertTrue(GrouperClientWs.mostRecentRequest,
31472 !GrouperClientWs.mostRecentRequest.contains("actions"));
31473 assertTrue(GrouperClientWs.mostRecentRequest,
31474 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31475 assertTrue(GrouperClientWs.mostRecentRequest,
31476 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31477 assertTrue(GrouperClientWs.mostRecentRequest,
31478 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31479 assertTrue(GrouperClientWs.mostRecentRequest,
31480 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31481 assertTrue(GrouperClientWs.mostRecentRequest,
31482 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31483 assertTrue(GrouperClientWs.mostRecentRequest,
31484 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31485 assertTrue(GrouperClientWs.mostRecentRequest,
31486 !GrouperClientWs.mostRecentRequest.contains("params"));
31487 assertTrue(GrouperClientWs.mostRecentRequest,
31488 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31489 assertTrue(GrouperClientWs.mostRecentRequest,
31490 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31491 assertTrue(GrouperClientWs.mostRecentRequest,
31492 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31493 assertTrue(GrouperClientWs.mostRecentRequest,
31494 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31495 assertTrue(GrouperClientWs.mostRecentRequest,
31496 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31497 assertTrue(GrouperClientWs.mostRecentRequest,
31498 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31499 assertTrue(GrouperClientWs.mostRecentRequest,
31500 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31501 assertTrue(GrouperClientWs.mostRecentRequest,
31502 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31503 assertTrue(GrouperClientWs.mostRecentRequest,
31504 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31505 assertTrue(GrouperClientWs.mostRecentRequest,
31506 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31507 assertTrue(GrouperClientWs.mostRecentRequest,
31508 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31509 assertTrue(GrouperClientWs.mostRecentRequest,
31510 GrouperClientWs.mostRecentRequest.contains("theValue"));
31511 assertTrue(GrouperClientWs.mostRecentRequest,
31512 GrouperClientWs.mostRecentRequest.contains("abc"));
31513 assertTrue(GrouperClientWs.mostRecentRequest,
31514 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31515 assertTrue(GrouperClientWs.mostRecentRequest,
31516 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31517 assertTrue(GrouperClientWs.mostRecentRequest,
31518 GrouperClientWs.mostRecentRequest.contains("limit"));
31519 assertTrue(GrouperClientWs.mostRecentRequest,
31520 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31521 assertTrue(GrouperClientWs.mostRecentRequest,
31522 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31523 assertTrue(GrouperClientWs.mostRecentRequest,
31524 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31525 assertTrue(GrouperClientWs.mostRecentRequest,
31526 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31527 assertTrue(GrouperClientWs.mostRecentRequest,
31528 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31529 assertTrue(GrouperClientWs.mostRecentRequest,
31530 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31531
31532
31533
31534
31535 baos = new ByteArrayOutputStream();
31536 System.setOut(new PrintStream(baos));
31537
31538 GrouperClient.main(GrouperClientUtils.splitTrim(
31539 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId(),
31540 " "));
31541
31542 System.out.flush();
31543 output = new String(baos.toByteArray());
31544
31545 System.setOut(systemOut);
31546
31547 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31548
31549
31550
31551 pattern = Pattern
31552 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31553
31554 assertEquals(1, GrouperUtil.length(outputLines));
31555 outputLine = outputLines[0];
31556
31557 matcher = pattern.matcher(outputLines[0]);
31558
31559 assertTrue(outputLine, matcher.matches());
31560 assertEquals(outputLine, "0", matcher.group(1));
31561 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
31562 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31563 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31564 assertEquals(outputLine, "assign", matcher.group(5));
31565 assertEquals(outputLine, "123", matcher.group(6));
31566 assertEquals(outputLine, "T", matcher.group(7));
31567 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31568
31569 assertTrue(GrouperClientWs.mostRecentRequest,
31570 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31571 assertTrue(GrouperClientWs.mostRecentRequest,
31572 !GrouperClientWs.mostRecentRequest.contains("actions"));
31573 assertTrue(GrouperClientWs.mostRecentRequest,
31574 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31575 assertTrue(GrouperClientWs.mostRecentRequest,
31576 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31577 assertTrue(GrouperClientWs.mostRecentRequest,
31578 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31579 assertTrue(GrouperClientWs.mostRecentRequest,
31580 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31581 assertTrue(GrouperClientWs.mostRecentRequest,
31582 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31583 assertTrue(GrouperClientWs.mostRecentRequest,
31584 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31585 assertTrue(GrouperClientWs.mostRecentRequest,
31586 !GrouperClientWs.mostRecentRequest.contains("params"));
31587 assertTrue(GrouperClientWs.mostRecentRequest,
31588 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31589 assertTrue(GrouperClientWs.mostRecentRequest,
31590 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31591 assertTrue(GrouperClientWs.mostRecentRequest,
31592 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31593 assertTrue(GrouperClientWs.mostRecentRequest,
31594 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31595 assertTrue(GrouperClientWs.mostRecentRequest,
31596 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31597 assertTrue(GrouperClientWs.mostRecentRequest,
31598 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31599 assertTrue(GrouperClientWs.mostRecentRequest,
31600 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31601 assertTrue(GrouperClientWs.mostRecentRequest,
31602 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31603 assertTrue(GrouperClientWs.mostRecentRequest,
31604 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31605 assertTrue(GrouperClientWs.mostRecentRequest,
31606 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31607 assertFalse(GrouperClientWs.mostRecentRequest,
31608 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31609 assertFalse(GrouperClientWs.mostRecentRequest,
31610 GrouperClientWs.mostRecentRequest.contains("theValue"));
31611 assertFalse(GrouperClientWs.mostRecentRequest,
31612 GrouperClientWs.mostRecentRequest.contains(">abc<"));
31613 assertTrue(GrouperClientWs.mostRecentRequest,
31614 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31615 assertFalse(GrouperClientWs.mostRecentRequest,
31616 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31617 assertTrue(GrouperClientWs.mostRecentRequest,
31618 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31619 assertTrue(GrouperClientWs.mostRecentRequest,
31620 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31621 assertTrue(GrouperClientWs.mostRecentRequest,
31622 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31623 assertTrue(GrouperClientWs.mostRecentRequest,
31624 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31625 assertTrue(GrouperClientWs.mostRecentRequest,
31626 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31627 assertTrue(GrouperClientWs.mostRecentRequest,
31628 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31629
31630
31631
31632
31633 baos = new ByteArrayOutputStream();
31634 System.setOut(new PrintStream(baos));
31635
31636 try {
31637 GrouperClient.main(GrouperClientUtils.splitTrim(
31638 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
31639 " "));
31640
31641 System.out.flush();
31642 output = new String(baos.toByteArray());
31643
31644 System.setOut(systemOut);
31645
31646 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31647
31648
31649
31650 pattern = Pattern
31651 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31652
31653 assertEquals(0, GrouperUtil.length(outputLines));
31654 fail("Why did it not fail?");
31655 } catch (Exception e) {
31656
31657 }
31658 assertTrue(GrouperClientWs.mostRecentRequest,
31659 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31660 assertTrue(GrouperClientWs.mostRecentRequest,
31661 !GrouperClientWs.mostRecentRequest.contains("actions"));
31662 assertTrue(GrouperClientWs.mostRecentRequest,
31663 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31664 assertTrue(GrouperClientWs.mostRecentRequest,
31665 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31666 assertTrue(GrouperClientWs.mostRecentRequest,
31667 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31668 assertTrue(GrouperClientWs.mostRecentRequest,
31669 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31670 assertTrue(GrouperClientWs.mostRecentRequest,
31671 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31672 assertTrue(GrouperClientWs.mostRecentRequest,
31673 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31674 assertTrue(GrouperClientWs.mostRecentRequest,
31675 !GrouperClientWs.mostRecentRequest.contains("params"));
31676 assertTrue(GrouperClientWs.mostRecentRequest,
31677 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31678 assertTrue(GrouperClientWs.mostRecentRequest,
31679 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31680 assertTrue(GrouperClientWs.mostRecentRequest,
31681 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31682 assertTrue(GrouperClientWs.mostRecentRequest,
31683 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31684 assertTrue(GrouperClientWs.mostRecentRequest,
31685 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31686 assertTrue(GrouperClientWs.mostRecentRequest,
31687 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31688 assertTrue(GrouperClientWs.mostRecentRequest,
31689 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31690 assertTrue(GrouperClientWs.mostRecentRequest,
31691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31692 assertTrue(GrouperClientWs.mostRecentRequest,
31693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31694 assertTrue(GrouperClientWs.mostRecentRequest,
31695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31696 assertFalse(GrouperClientWs.mostRecentRequest,
31697 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31698 assertFalse(GrouperClientWs.mostRecentRequest,
31699 GrouperClientWs.mostRecentRequest.contains("theValue"));
31700 assertFalse(GrouperClientWs.mostRecentRequest,
31701 GrouperClientWs.mostRecentRequest.contains("abc"));
31702 assertTrue(GrouperClientWs.mostRecentRequest,
31703 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31704 assertFalse(GrouperClientWs.mostRecentRequest,
31705 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31706 assertTrue(GrouperClientWs.mostRecentRequest,
31707 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31708 assertTrue(GrouperClientWs.mostRecentRequest,
31709 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31710 assertTrue(GrouperClientWs.mostRecentRequest,
31711 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31712 assertTrue(GrouperClientWs.mostRecentRequest,
31713 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31714 assertTrue(GrouperClientWs.mostRecentRequest,
31715 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31716 assertTrue(GrouperClientWs.mostRecentRequest,
31717 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31718
31719
31720
31721
31722
31723 baos = new ByteArrayOutputStream();
31724 System.setOut(new PrintStream(baos));
31725
31726 GrouperClient.main(GrouperClientUtils.splitTrim(
31727 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
31728 + " --attributeDefValueType=integer --value=123 ",
31729 " "));
31730
31731 System.out.flush();
31732 output = new String(baos.toByteArray());
31733
31734 System.setOut(systemOut);
31735
31736 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31737
31738
31739
31740 pattern = Pattern
31741 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31742
31743 assertEquals(1, GrouperUtil.length(outputLines));
31744 outputLine = outputLines[0];
31745
31746 matcher = pattern.matcher(outputLines[0]);
31747
31748 assertTrue(outputLine, matcher.matches());
31749 assertEquals(outputLine, "0", matcher.group(1));
31750 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
31751 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31752 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31753 assertEquals(outputLine, "assign", matcher.group(5));
31754 assertEquals(outputLine, "123", matcher.group(6));
31755 assertEquals(outputLine, "T", matcher.group(7));
31756 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31757
31758 assertTrue(GrouperClientWs.mostRecentRequest,
31759 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31760 assertTrue(GrouperClientWs.mostRecentRequest,
31761 !GrouperClientWs.mostRecentRequest.contains("actions"));
31762 assertTrue(GrouperClientWs.mostRecentRequest,
31763 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31764 assertTrue(GrouperClientWs.mostRecentRequest,
31765 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31766 assertTrue(GrouperClientWs.mostRecentRequest,
31767 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31768 assertTrue(GrouperClientWs.mostRecentRequest,
31769 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31770 assertTrue(GrouperClientWs.mostRecentRequest,
31771 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31772 assertTrue(GrouperClientWs.mostRecentRequest,
31773 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31774 assertTrue(GrouperClientWs.mostRecentRequest,
31775 !GrouperClientWs.mostRecentRequest.contains("params"));
31776 assertTrue(GrouperClientWs.mostRecentRequest,
31777 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31778 assertTrue(GrouperClientWs.mostRecentRequest,
31779 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31780 assertTrue(GrouperClientWs.mostRecentRequest,
31781 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31782 assertTrue(GrouperClientWs.mostRecentRequest,
31783 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31784 assertTrue(GrouperClientWs.mostRecentRequest,
31785 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31786 assertTrue(GrouperClientWs.mostRecentRequest,
31787 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31788 assertTrue(GrouperClientWs.mostRecentRequest,
31789 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31790 assertTrue(GrouperClientWs.mostRecentRequest,
31791 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31792 assertTrue(GrouperClientWs.mostRecentRequest,
31793 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31794 assertTrue(GrouperClientWs.mostRecentRequest,
31795 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31796 assertTrue(GrouperClientWs.mostRecentRequest,
31797 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31798 assertTrue(GrouperClientWs.mostRecentRequest,
31799 GrouperClientWs.mostRecentRequest.contains("theValue"));
31800 assertTrue(GrouperClientWs.mostRecentRequest,
31801 GrouperClientWs.mostRecentRequest.contains(">123<"));
31802 assertTrue(GrouperClientWs.mostRecentRequest,
31803 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31804 assertFalse(GrouperClientWs.mostRecentRequest,
31805 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31806 assertTrue(GrouperClientWs.mostRecentRequest,
31807 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31808 assertTrue(GrouperClientWs.mostRecentRequest,
31809 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31810 assertTrue(GrouperClientWs.mostRecentRequest,
31811 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31812 assertTrue(GrouperClientWs.mostRecentRequest,
31813 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31814 assertTrue(GrouperClientWs.mostRecentRequest,
31815 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31816 assertTrue(GrouperClientWs.mostRecentRequest,
31817 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31818
31819
31820
31821
31822
31823 baos = new ByteArrayOutputStream();
31824 System.setOut(new PrintStream(baos));
31825
31826 GrouperClient.main(GrouperClientUtils.splitTrim(
31827 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
31828 + " --attributeDefValueType=integer --value=1234 ",
31829 " "));
31830
31831 System.out.flush();
31832 output = new String(baos.toByteArray());
31833
31834 System.setOut(systemOut);
31835
31836 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31837
31838
31839
31840 pattern = Pattern
31841 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31842
31843 assertEquals(0, GrouperUtil.length(outputLines));
31844
31845 assertTrue(GrouperClientWs.mostRecentRequest,
31846 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31847 assertTrue(GrouperClientWs.mostRecentRequest,
31848 !GrouperClientWs.mostRecentRequest.contains("actions"));
31849 assertTrue(GrouperClientWs.mostRecentRequest,
31850 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31851 assertTrue(GrouperClientWs.mostRecentRequest,
31852 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31853 assertTrue(GrouperClientWs.mostRecentRequest,
31854 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31855 assertTrue(GrouperClientWs.mostRecentRequest,
31856 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31857 assertTrue(GrouperClientWs.mostRecentRequest,
31858 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31859 assertTrue(GrouperClientWs.mostRecentRequest,
31860 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31861 assertTrue(GrouperClientWs.mostRecentRequest,
31862 !GrouperClientWs.mostRecentRequest.contains("params"));
31863 assertTrue(GrouperClientWs.mostRecentRequest,
31864 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31865 assertTrue(GrouperClientWs.mostRecentRequest,
31866 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31867 assertTrue(GrouperClientWs.mostRecentRequest,
31868 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31869 assertTrue(GrouperClientWs.mostRecentRequest,
31870 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31871 assertTrue(GrouperClientWs.mostRecentRequest,
31872 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31873 assertTrue(GrouperClientWs.mostRecentRequest,
31874 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31875 assertTrue(GrouperClientWs.mostRecentRequest,
31876 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31877 assertTrue(GrouperClientWs.mostRecentRequest,
31878 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31879 assertTrue(GrouperClientWs.mostRecentRequest,
31880 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31881 assertTrue(GrouperClientWs.mostRecentRequest,
31882 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31883 assertTrue(GrouperClientWs.mostRecentRequest,
31884 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31885 assertTrue(GrouperClientWs.mostRecentRequest,
31886 GrouperClientWs.mostRecentRequest.contains("theValue"));
31887 assertTrue(GrouperClientWs.mostRecentRequest,
31888 GrouperClientWs.mostRecentRequest.contains("1234"));
31889 assertTrue(GrouperClientWs.mostRecentRequest,
31890 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31891 assertFalse(GrouperClientWs.mostRecentRequest,
31892 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31893 assertTrue(GrouperClientWs.mostRecentRequest,
31894 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31895 assertTrue(GrouperClientWs.mostRecentRequest,
31896 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31897 assertTrue(GrouperClientWs.mostRecentRequest,
31898 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31899 assertTrue(GrouperClientWs.mostRecentRequest,
31900 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31901 assertTrue(GrouperClientWs.mostRecentRequest,
31902 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31903 assertTrue(GrouperClientWs.mostRecentRequest,
31904 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31905
31906
31907
31908
31909
31910 baos = new ByteArrayOutputStream();
31911 System.setOut(new PrintStream(baos));
31912
31913 GrouperClient.main(GrouperClientUtils.splitTrim(
31914 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
31915 + " --includeAssignmentsFromAssignments=T ",
31916 " "));
31917
31918 System.out.flush();
31919 output = new String(baos.toByteArray());
31920
31921 System.setOut(systemOut);
31922
31923 outputLines = GrouperClientUtils.splitTrim(output, "\n");
31924
31925
31926
31927 pattern = Pattern
31928 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31929
31930 assertEquals(2, GrouperUtil.length(outputLines));
31931 outputLine = outputLines[0];
31932
31933 matcher = pattern.matcher(outputLine);
31934
31935 assertTrue(outputLine, matcher.matches());
31936 assertEquals(outputLine, "0", matcher.group(1));
31937 assertEquals(outputLine, "imm_mem", matcher.group(2));
31938 assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
31939 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
31940 assertEquals(outputLine, "assign", matcher.group(5));
31941 assertEquals(outputLine, "abc", matcher.group(6));
31942 assertEquals(outputLine, "T", matcher.group(7));
31943 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
31944
31945 outputLine = outputLines[1];
31946
31947 matcher = pattern.matcher(outputLine);
31948
31949 assertTrue(outputLine, matcher.matches());
31950 assertEquals(outputLine, "1", matcher.group(1));
31951 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
31952 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31953 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31954 assertEquals(outputLine, "assign", matcher.group(5));
31955 assertEquals(outputLine, "123", matcher.group(6));
31956 assertEquals(outputLine, "T", matcher.group(7));
31957 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31958
31959 assertTrue(GrouperClientWs.mostRecentRequest,
31960 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31961 assertTrue(GrouperClientWs.mostRecentRequest,
31962 !GrouperClientWs.mostRecentRequest.contains("actions"));
31963 assertTrue(GrouperClientWs.mostRecentRequest,
31964 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31965 assertTrue(GrouperClientWs.mostRecentRequest,
31966 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31967 assertTrue(GrouperClientWs.mostRecentRequest,
31968 !GrouperClientWs.mostRecentRequest.contains("enabled"));
31969 assertTrue(GrouperClientWs.mostRecentRequest,
31970 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31971 assertTrue(GrouperClientWs.mostRecentRequest,
31972 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31973 assertTrue(GrouperClientWs.mostRecentRequest,
31974 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31975 assertTrue(GrouperClientWs.mostRecentRequest,
31976 !GrouperClientWs.mostRecentRequest.contains("params"));
31977 assertTrue(GrouperClientWs.mostRecentRequest,
31978 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31979 assertTrue(GrouperClientWs.mostRecentRequest,
31980 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31981 assertTrue(GrouperClientWs.mostRecentRequest,
31982 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31983 assertTrue(GrouperClientWs.mostRecentRequest,
31984 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31985 assertTrue(GrouperClientWs.mostRecentRequest,
31986 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31987 assertTrue(GrouperClientWs.mostRecentRequest,
31988 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31989 assertTrue(GrouperClientWs.mostRecentRequest,
31990 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31991 assertTrue(GrouperClientWs.mostRecentRequest,
31992 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31993 assertTrue(GrouperClientWs.mostRecentRequest,
31994 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31995 assertTrue(GrouperClientWs.mostRecentRequest,
31996 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31997 assertFalse(GrouperClientWs.mostRecentRequest,
31998 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31999 assertFalse(GrouperClientWs.mostRecentRequest,
32000 GrouperClientWs.mostRecentRequest.contains("theValue"));
32001 assertFalse(GrouperClientWs.mostRecentRequest,
32002 GrouperClientWs.mostRecentRequest.contains(">123<"));
32003 assertTrue(GrouperClientWs.mostRecentRequest,
32004 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32005 assertFalse(GrouperClientWs.mostRecentRequest,
32006 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32007 assertTrue(GrouperClientWs.mostRecentRequest,
32008 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32009 assertTrue(GrouperClientWs.mostRecentRequest,
32010 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32011 assertTrue(GrouperClientWs.mostRecentRequest,
32012 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32013 assertTrue(GrouperClientWs.mostRecentRequest,
32014 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32015 assertTrue(GrouperClientWs.mostRecentRequest,
32016 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32017 assertTrue(GrouperClientWs.mostRecentRequest,
32018 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32019
32020
32021
32022
32023
32024 baos = new ByteArrayOutputStream();
32025 System.setOut(new PrintStream(baos));
32026
32027 try {
32028 GrouperClient.main(GrouperClientUtils.splitTrim(
32029 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
32030 ,
32031 " "));
32032
32033 System.out.flush();
32034 output = new String(baos.toByteArray());
32035
32036 System.setOut(systemOut);
32037
32038 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32039
32040
32041
32042 pattern = Pattern
32043 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32044
32045 assertEquals(0, GrouperUtil.length(outputLines));
32046 fail("Shouldnt get here");
32047 } catch (Exception e) {
32048
32049 } finally {
32050 System.setOut(systemOut);
32051
32052 }
32053
32054 assertTrue(GrouperClientWs.mostRecentRequest,
32055 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32056 assertTrue(GrouperClientWs.mostRecentRequest,
32057 !GrouperClientWs.mostRecentRequest.contains("actions"));
32058 assertTrue(GrouperClientWs.mostRecentRequest,
32059 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32060 assertTrue(GrouperClientWs.mostRecentRequest,
32061 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32062 assertTrue(GrouperClientWs.mostRecentRequest,
32063 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32064 assertTrue(GrouperClientWs.mostRecentRequest,
32065 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32066 assertTrue(GrouperClientWs.mostRecentRequest,
32067 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32068 assertTrue(GrouperClientWs.mostRecentRequest,
32069 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32070 assertTrue(GrouperClientWs.mostRecentRequest,
32071 !GrouperClientWs.mostRecentRequest.contains("params"));
32072 assertTrue(GrouperClientWs.mostRecentRequest,
32073 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32074 assertTrue(GrouperClientWs.mostRecentRequest,
32075 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32076 assertFalse(GrouperClientWs.mostRecentRequest,
32077 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32078 assertTrue(GrouperClientWs.mostRecentRequest,
32079 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32080 assertTrue(GrouperClientWs.mostRecentRequest,
32081 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32082 assertTrue(GrouperClientWs.mostRecentRequest,
32083 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32084 assertTrue(GrouperClientWs.mostRecentRequest,
32085 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32086 assertTrue(GrouperClientWs.mostRecentRequest,
32087 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32088 assertTrue(GrouperClientWs.mostRecentRequest,
32089 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32090 assertTrue(GrouperClientWs.mostRecentRequest,
32091 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32092 assertTrue(GrouperClientWs.mostRecentRequest,
32093 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32094 assertFalse(GrouperClientWs.mostRecentRequest,
32095 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32096 assertFalse(GrouperClientWs.mostRecentRequest,
32097 GrouperClientWs.mostRecentRequest.contains("theValue"));
32098 assertFalse(GrouperClientWs.mostRecentRequest,
32099 GrouperClientWs.mostRecentRequest.contains(">123<"));
32100 assertFalse(GrouperClientWs.mostRecentRequest,
32101 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32102 assertFalse(GrouperClientWs.mostRecentRequest,
32103 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32104 assertTrue(GrouperClientWs.mostRecentRequest,
32105 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32106 assertTrue(GrouperClientWs.mostRecentRequest,
32107 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32108 assertTrue(GrouperClientWs.mostRecentRequest,
32109 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32110 assertTrue(GrouperClientWs.mostRecentRequest,
32111 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32112 assertTrue(GrouperClientWs.mostRecentRequest,
32113 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32114 assertTrue(GrouperClientWs.mostRecentRequest,
32115 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32116
32117
32118
32119
32120 baos = new ByteArrayOutputStream();
32121 System.setOut(new PrintStream(baos));
32122
32123 GrouperClient.main(GrouperClientUtils.splitTrim(
32124 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
32125 ,
32126 " "));
32127
32128 System.out.flush();
32129 output = new String(baos.toByteArray());
32130
32131 System.setOut(systemOut);
32132
32133 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32134
32135
32136
32137 pattern = Pattern
32138 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32139
32140 assertEquals(1, GrouperUtil.length(outputLines));
32141
32142 outputLine = outputLines[0];
32143
32144 matcher = pattern.matcher(outputLine);
32145
32146 assertTrue(outputLine, matcher.matches());
32147 assertEquals(outputLine, "0", matcher.group(1));
32148 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32149 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32150 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32151 assertEquals(outputLine, "assign", matcher.group(5));
32152 assertEquals(outputLine, "123", matcher.group(6));
32153 assertEquals(outputLine, "T", matcher.group(7));
32154 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32155
32156 assertTrue(GrouperClientWs.mostRecentRequest,
32157 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32158 assertTrue(GrouperClientWs.mostRecentRequest,
32159 !GrouperClientWs.mostRecentRequest.contains("actions"));
32160 assertTrue(GrouperClientWs.mostRecentRequest,
32161 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32162 assertTrue(GrouperClientWs.mostRecentRequest,
32163 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32164 assertTrue(GrouperClientWs.mostRecentRequest,
32165 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32166 assertTrue(GrouperClientWs.mostRecentRequest,
32167 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32168 assertTrue(GrouperClientWs.mostRecentRequest,
32169 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32170 assertTrue(GrouperClientWs.mostRecentRequest,
32171 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32172 assertTrue(GrouperClientWs.mostRecentRequest,
32173 !GrouperClientWs.mostRecentRequest.contains("params"));
32174 assertTrue(GrouperClientWs.mostRecentRequest,
32175 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32176 assertTrue(GrouperClientWs.mostRecentRequest,
32177 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32178 assertFalse(GrouperClientWs.mostRecentRequest,
32179 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32180 assertTrue(GrouperClientWs.mostRecentRequest,
32181 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32182 assertTrue(GrouperClientWs.mostRecentRequest,
32183 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32184 assertTrue(GrouperClientWs.mostRecentRequest,
32185 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32186 assertTrue(GrouperClientWs.mostRecentRequest,
32187 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32188 assertTrue(GrouperClientWs.mostRecentRequest,
32189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32190 assertTrue(GrouperClientWs.mostRecentRequest,
32191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32192 assertTrue(GrouperClientWs.mostRecentRequest,
32193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32194 assertTrue(GrouperClientWs.mostRecentRequest,
32195 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32196 assertFalse(GrouperClientWs.mostRecentRequest,
32197 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32198 assertFalse(GrouperClientWs.mostRecentRequest,
32199 GrouperClientWs.mostRecentRequest.contains("theValue"));
32200 assertFalse(GrouperClientWs.mostRecentRequest,
32201 GrouperClientWs.mostRecentRequest.contains(">123<"));
32202 assertFalse(GrouperClientWs.mostRecentRequest,
32203 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32204 assertFalse(GrouperClientWs.mostRecentRequest,
32205 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32206 assertTrue(GrouperClientWs.mostRecentRequest,
32207 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32208 assertTrue(GrouperClientWs.mostRecentRequest,
32209 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32210 assertTrue(GrouperClientWs.mostRecentRequest,
32211 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32212 assertTrue(GrouperClientWs.mostRecentRequest,
32213 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32214 assertTrue(GrouperClientWs.mostRecentRequest,
32215 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32216 assertTrue(GrouperClientWs.mostRecentRequest,
32217 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32218
32219
32220
32221
32222
32223 baos = new ByteArrayOutputStream();
32224 System.setOut(new PrintStream(baos));
32225
32226 GrouperClient.main(GrouperClientUtils.splitTrim(
32227 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
32228 ,
32229 " "));
32230
32231 System.out.flush();
32232 output = new String(baos.toByteArray());
32233
32234 System.setOut(systemOut);
32235
32236 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32237
32238
32239
32240 pattern = Pattern
32241 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32242
32243 assertEquals(1, GrouperUtil.length(outputLines));
32244
32245 outputLine = outputLines[0];
32246
32247 matcher = pattern.matcher(outputLine);
32248
32249 assertTrue(outputLine, matcher.matches());
32250 assertEquals(outputLine, "0", matcher.group(1));
32251 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32252 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32253 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32254 assertEquals(outputLine, "assign", matcher.group(5));
32255 assertEquals(outputLine, "123", matcher.group(6));
32256 assertEquals(outputLine, "T", matcher.group(7));
32257 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32258
32259 assertTrue(GrouperClientWs.mostRecentRequest,
32260 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32261 assertTrue(GrouperClientWs.mostRecentRequest,
32262 !GrouperClientWs.mostRecentRequest.contains("actions"));
32263 assertTrue(GrouperClientWs.mostRecentRequest,
32264 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32265 assertTrue(GrouperClientWs.mostRecentRequest,
32266 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32267 assertTrue(GrouperClientWs.mostRecentRequest,
32268 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32269 assertTrue(GrouperClientWs.mostRecentRequest,
32270 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32271 assertTrue(GrouperClientWs.mostRecentRequest,
32272 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32273 assertTrue(GrouperClientWs.mostRecentRequest,
32274 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32275 assertTrue(GrouperClientWs.mostRecentRequest,
32276 !GrouperClientWs.mostRecentRequest.contains("params"));
32277 assertTrue(GrouperClientWs.mostRecentRequest,
32278 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32279 assertTrue(GrouperClientWs.mostRecentRequest,
32280 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32281 assertFalse(GrouperClientWs.mostRecentRequest,
32282 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32283 assertFalse(GrouperClientWs.mostRecentRequest,
32284 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32285 assertTrue(GrouperClientWs.mostRecentRequest,
32286 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32287 assertTrue(GrouperClientWs.mostRecentRequest,
32288 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32289 assertTrue(GrouperClientWs.mostRecentRequest,
32290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32291 assertTrue(GrouperClientWs.mostRecentRequest,
32292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32293 assertTrue(GrouperClientWs.mostRecentRequest,
32294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32295 assertTrue(GrouperClientWs.mostRecentRequest,
32296 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32297 assertTrue(GrouperClientWs.mostRecentRequest,
32298 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32299 assertFalse(GrouperClientWs.mostRecentRequest,
32300 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32301 assertFalse(GrouperClientWs.mostRecentRequest,
32302 GrouperClientWs.mostRecentRequest.contains("theValue"));
32303 assertFalse(GrouperClientWs.mostRecentRequest,
32304 GrouperClientWs.mostRecentRequest.contains(">123<"));
32305 assertFalse(GrouperClientWs.mostRecentRequest,
32306 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32307 assertFalse(GrouperClientWs.mostRecentRequest,
32308 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32309 assertTrue(GrouperClientWs.mostRecentRequest,
32310 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32311 assertTrue(GrouperClientWs.mostRecentRequest,
32312 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32313 assertTrue(GrouperClientWs.mostRecentRequest,
32314 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32315 assertTrue(GrouperClientWs.mostRecentRequest,
32316 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32317 assertTrue(GrouperClientWs.mostRecentRequest,
32318 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32319 assertTrue(GrouperClientWs.mostRecentRequest,
32320 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32321
32322
32323
32324
32325
32326
32327 baos = new ByteArrayOutputStream();
32328 System.setOut(new PrintStream(baos));
32329
32330 try {
32331 GrouperClient.main(GrouperClientUtils.splitTrim(
32332 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
32333 ,
32334 " "));
32335
32336 System.out.flush();
32337 output = new String(baos.toByteArray());
32338
32339 System.setOut(systemOut);
32340
32341 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32342
32343
32344
32345 pattern = Pattern
32346 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32347
32348 assertEquals(0, GrouperUtil.length(outputLines));
32349
32350 fail("shouldnt get here");
32351 } catch (Exception e) {
32352
32353 } finally {
32354 System.setOut(systemOut);
32355 }
32356
32357 assertTrue(GrouperClientWs.mostRecentRequest,
32358 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32359 assertTrue(GrouperClientWs.mostRecentRequest,
32360 !GrouperClientWs.mostRecentRequest.contains("actions"));
32361 assertTrue(GrouperClientWs.mostRecentRequest,
32362 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32363 assertTrue(GrouperClientWs.mostRecentRequest,
32364 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32365 assertTrue(GrouperClientWs.mostRecentRequest,
32366 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32367 assertTrue(GrouperClientWs.mostRecentRequest,
32368 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32369 assertTrue(GrouperClientWs.mostRecentRequest,
32370 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32371 assertTrue(GrouperClientWs.mostRecentRequest,
32372 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32373 assertTrue(GrouperClientWs.mostRecentRequest,
32374 !GrouperClientWs.mostRecentRequest.contains("params"));
32375 assertTrue(GrouperClientWs.mostRecentRequest,
32376 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32377 assertTrue(GrouperClientWs.mostRecentRequest,
32378 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32379 assertFalse(GrouperClientWs.mostRecentRequest,
32380 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32381 assertFalse(GrouperClientWs.mostRecentRequest,
32382 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32383 assertTrue(GrouperClientWs.mostRecentRequest,
32384 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32385 assertTrue(GrouperClientWs.mostRecentRequest,
32386 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32387 assertTrue(GrouperClientWs.mostRecentRequest,
32388 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32389 assertTrue(GrouperClientWs.mostRecentRequest,
32390 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32391 assertTrue(GrouperClientWs.mostRecentRequest,
32392 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32393 assertTrue(GrouperClientWs.mostRecentRequest,
32394 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32395 assertTrue(GrouperClientWs.mostRecentRequest,
32396 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32397 assertFalse(GrouperClientWs.mostRecentRequest,
32398 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32399 assertFalse(GrouperClientWs.mostRecentRequest,
32400 GrouperClientWs.mostRecentRequest.contains("theValue"));
32401 assertFalse(GrouperClientWs.mostRecentRequest,
32402 GrouperClientWs.mostRecentRequest.contains(">123<"));
32403 assertFalse(GrouperClientWs.mostRecentRequest,
32404 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32405 assertFalse(GrouperClientWs.mostRecentRequest,
32406 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32407 assertTrue(GrouperClientWs.mostRecentRequest,
32408 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32409 assertTrue(GrouperClientWs.mostRecentRequest,
32410 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32411 assertTrue(GrouperClientWs.mostRecentRequest,
32412 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32413 assertTrue(GrouperClientWs.mostRecentRequest,
32414 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32415 assertTrue(GrouperClientWs.mostRecentRequest,
32416 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32417 assertTrue(GrouperClientWs.mostRecentRequest,
32418 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32419
32420
32421
32422
32423
32424 baos = new ByteArrayOutputStream();
32425 System.setOut(new PrintStream(baos));
32426
32427 GrouperClient.main(GrouperClientUtils.splitTrim(
32428 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
32429 ,
32430 " "));
32431
32432 System.out.flush();
32433 output = new String(baos.toByteArray());
32434
32435 System.setOut(systemOut);
32436
32437 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32438
32439
32440
32441 pattern = Pattern
32442 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32443
32444 assertEquals(1, GrouperUtil.length(outputLines));
32445
32446 outputLine = outputLines[0];
32447
32448 matcher = pattern.matcher(outputLine);
32449
32450 assertTrue(outputLine, matcher.matches());
32451 assertEquals(outputLine, "0", matcher.group(1));
32452 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32453 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32454 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32455 assertEquals(outputLine, "assign", matcher.group(5));
32456 assertEquals(outputLine, "123", matcher.group(6));
32457 assertEquals(outputLine, "T", matcher.group(7));
32458 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32459
32460 assertTrue(GrouperClientWs.mostRecentRequest,
32461 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32462 assertTrue(GrouperClientWs.mostRecentRequest,
32463 !GrouperClientWs.mostRecentRequest.contains("actions"));
32464 assertTrue(GrouperClientWs.mostRecentRequest,
32465 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32466 assertTrue(GrouperClientWs.mostRecentRequest,
32467 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32468 assertTrue(GrouperClientWs.mostRecentRequest,
32469 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32470 assertTrue(GrouperClientWs.mostRecentRequest,
32471 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32472 assertTrue(GrouperClientWs.mostRecentRequest,
32473 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32474 assertTrue(GrouperClientWs.mostRecentRequest,
32475 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32476 assertTrue(GrouperClientWs.mostRecentRequest,
32477 !GrouperClientWs.mostRecentRequest.contains("params"));
32478 assertTrue(GrouperClientWs.mostRecentRequest,
32479 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32480 assertTrue(GrouperClientWs.mostRecentRequest,
32481 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32482 assertFalse(GrouperClientWs.mostRecentRequest,
32483 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32484 assertTrue(GrouperClientWs.mostRecentRequest,
32485 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32486 assertTrue(GrouperClientWs.mostRecentRequest,
32487 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32488 assertTrue(GrouperClientWs.mostRecentRequest,
32489 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32490 assertTrue(GrouperClientWs.mostRecentRequest,
32491 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32492 assertTrue(GrouperClientWs.mostRecentRequest,
32493 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32494 assertTrue(GrouperClientWs.mostRecentRequest,
32495 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32496 assertTrue(GrouperClientWs.mostRecentRequest,
32497 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32498 assertTrue(GrouperClientWs.mostRecentRequest,
32499 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32500 assertFalse(GrouperClientWs.mostRecentRequest,
32501 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32502 assertFalse(GrouperClientWs.mostRecentRequest,
32503 GrouperClientWs.mostRecentRequest.contains("theValue"));
32504 assertFalse(GrouperClientWs.mostRecentRequest,
32505 GrouperClientWs.mostRecentRequest.contains(">123<"));
32506 assertFalse(GrouperClientWs.mostRecentRequest,
32507 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32508 assertFalse(GrouperClientWs.mostRecentRequest,
32509 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32510 assertTrue(GrouperClientWs.mostRecentRequest,
32511 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32512 assertTrue(GrouperClientWs.mostRecentRequest,
32513 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32514 assertTrue(GrouperClientWs.mostRecentRequest,
32515 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32516 assertTrue(GrouperClientWs.mostRecentRequest,
32517 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32518 assertTrue(GrouperClientWs.mostRecentRequest,
32519 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32520 assertTrue(GrouperClientWs.mostRecentRequest,
32521 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32522
32523
32524
32525
32526
32527 baos = new ByteArrayOutputStream();
32528 System.setOut(new PrintStream(baos));
32529
32530 GrouperClient.main(GrouperClientUtils.splitTrim(
32531 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
32532 ,
32533 " "));
32534
32535 System.out.flush();
32536 output = new String(baos.toByteArray());
32537
32538 System.setOut(systemOut);
32539
32540 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32541
32542
32543
32544 pattern = Pattern
32545 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32546
32547 assertEquals(1, GrouperUtil.length(outputLines));
32548
32549 outputLine = outputLines[0];
32550
32551 matcher = pattern.matcher(outputLine);
32552
32553 assertTrue(outputLine, matcher.matches());
32554 assertEquals(outputLine, "0", matcher.group(1));
32555 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32556 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32557 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32558 assertEquals(outputLine, "assign", matcher.group(5));
32559 assertEquals(outputLine, "123", matcher.group(6));
32560 assertEquals(outputLine, "T", matcher.group(7));
32561 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32562
32563 assertTrue(GrouperClientWs.mostRecentRequest,
32564 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32565 assertTrue(GrouperClientWs.mostRecentRequest,
32566 !GrouperClientWs.mostRecentRequest.contains("actions"));
32567 assertTrue(GrouperClientWs.mostRecentRequest,
32568 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32569 assertTrue(GrouperClientWs.mostRecentRequest,
32570 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32571 assertTrue(GrouperClientWs.mostRecentRequest,
32572 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32573 assertTrue(GrouperClientWs.mostRecentRequest,
32574 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32575 assertTrue(GrouperClientWs.mostRecentRequest,
32576 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32577 assertTrue(GrouperClientWs.mostRecentRequest,
32578 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32579 assertTrue(GrouperClientWs.mostRecentRequest,
32580 !GrouperClientWs.mostRecentRequest.contains("params"));
32581 assertTrue(GrouperClientWs.mostRecentRequest,
32582 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32583 assertTrue(GrouperClientWs.mostRecentRequest,
32584 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32585 assertFalse(GrouperClientWs.mostRecentRequest,
32586 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32587 assertTrue(GrouperClientWs.mostRecentRequest,
32588 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32589 assertTrue(GrouperClientWs.mostRecentRequest,
32590 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32591 assertTrue(GrouperClientWs.mostRecentRequest,
32592 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32593 assertTrue(GrouperClientWs.mostRecentRequest,
32594 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32595 assertTrue(GrouperClientWs.mostRecentRequest,
32596 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32597 assertTrue(GrouperClientWs.mostRecentRequest,
32598 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32599 assertTrue(GrouperClientWs.mostRecentRequest,
32600 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32601 assertTrue(GrouperClientWs.mostRecentRequest,
32602 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32603 assertFalse(GrouperClientWs.mostRecentRequest,
32604 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32605 assertFalse(GrouperClientWs.mostRecentRequest,
32606 GrouperClientWs.mostRecentRequest.contains("theValue"));
32607 assertFalse(GrouperClientWs.mostRecentRequest,
32608 GrouperClientWs.mostRecentRequest.contains(">123<"));
32609 assertFalse(GrouperClientWs.mostRecentRequest,
32610 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32611 assertFalse(GrouperClientWs.mostRecentRequest,
32612 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32613 assertTrue(GrouperClientWs.mostRecentRequest,
32614 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32615 assertTrue(GrouperClientWs.mostRecentRequest,
32616 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32617 assertTrue(GrouperClientWs.mostRecentRequest,
32618 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32619 assertTrue(GrouperClientWs.mostRecentRequest,
32620 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32621 assertTrue(GrouperClientWs.mostRecentRequest,
32622 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32623 assertTrue(GrouperClientWs.mostRecentRequest,
32624 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32625
32626
32627
32628
32629
32630
32631 baos = new ByteArrayOutputStream();
32632 System.setOut(new PrintStream(baos));
32633
32634 try {
32635 GrouperClient.main(GrouperClientUtils.splitTrim(
32636 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
32637 ,
32638 " "));
32639
32640 System.out.flush();
32641 output = new String(baos.toByteArray());
32642
32643 System.setOut(systemOut);
32644
32645 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32646
32647
32648
32649 pattern = Pattern
32650 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32651
32652 assertEquals(0, GrouperUtil.length(outputLines));
32653 fail("Shouldnt get here");
32654 } catch (Exception e) {
32655
32656 } finally {
32657
32658 System.setOut(systemOut);
32659
32660 }
32661
32662 assertTrue(GrouperClientWs.mostRecentRequest,
32663 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32664 assertTrue(GrouperClientWs.mostRecentRequest,
32665 !GrouperClientWs.mostRecentRequest.contains("actions"));
32666 assertTrue(GrouperClientWs.mostRecentRequest,
32667 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32668 assertTrue(GrouperClientWs.mostRecentRequest,
32669 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32670 assertTrue(GrouperClientWs.mostRecentRequest,
32671 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32672 assertTrue(GrouperClientWs.mostRecentRequest,
32673 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32674 assertTrue(GrouperClientWs.mostRecentRequest,
32675 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32676 assertTrue(GrouperClientWs.mostRecentRequest,
32677 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32678 assertTrue(GrouperClientWs.mostRecentRequest,
32679 !GrouperClientWs.mostRecentRequest.contains("params"));
32680 assertTrue(GrouperClientWs.mostRecentRequest,
32681 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32682 assertTrue(GrouperClientWs.mostRecentRequest,
32683 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32684 assertFalse(GrouperClientWs.mostRecentRequest,
32685 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32686 assertTrue(GrouperClientWs.mostRecentRequest,
32687 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32688 assertTrue(GrouperClientWs.mostRecentRequest,
32689 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32690 assertTrue(GrouperClientWs.mostRecentRequest,
32691 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32692 assertTrue(GrouperClientWs.mostRecentRequest,
32693 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32694 assertTrue(GrouperClientWs.mostRecentRequest,
32695 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32696 assertTrue(GrouperClientWs.mostRecentRequest,
32697 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32698 assertTrue(GrouperClientWs.mostRecentRequest,
32699 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32700 assertTrue(GrouperClientWs.mostRecentRequest,
32701 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32702 assertFalse(GrouperClientWs.mostRecentRequest,
32703 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32704 assertFalse(GrouperClientWs.mostRecentRequest,
32705 GrouperClientWs.mostRecentRequest.contains("theValue"));
32706 assertFalse(GrouperClientWs.mostRecentRequest,
32707 GrouperClientWs.mostRecentRequest.contains(">123<"));
32708 assertFalse(GrouperClientWs.mostRecentRequest,
32709 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32710 assertFalse(GrouperClientWs.mostRecentRequest,
32711 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32712 assertTrue(GrouperClientWs.mostRecentRequest,
32713 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32714 assertTrue(GrouperClientWs.mostRecentRequest,
32715 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32716 assertTrue(GrouperClientWs.mostRecentRequest,
32717 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32718 assertTrue(GrouperClientWs.mostRecentRequest,
32719 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32720 assertTrue(GrouperClientWs.mostRecentRequest,
32721 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32722 assertTrue(GrouperClientWs.mostRecentRequest,
32723 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32724
32725
32726
32727
32728
32729 baos = new ByteArrayOutputStream();
32730 System.setOut(new PrintStream(baos));
32731
32732 GrouperClient.main(GrouperClientUtils.splitTrim(
32733 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
32734 ,
32735 " "));
32736
32737 System.out.flush();
32738 output = new String(baos.toByteArray());
32739
32740 System.setOut(systemOut);
32741
32742 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32743
32744
32745
32746 pattern = Pattern
32747 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32748
32749 assertEquals(1, GrouperUtil.length(outputLines));
32750
32751 outputLine = outputLines[0];
32752
32753 matcher = pattern.matcher(outputLine);
32754
32755 assertTrue(outputLine, matcher.matches());
32756 assertEquals(outputLine, "0", matcher.group(1));
32757 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32758 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32759 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32760 assertEquals(outputLine, "assign", matcher.group(5));
32761 assertEquals(outputLine, "123", matcher.group(6));
32762 assertEquals(outputLine, "T", matcher.group(7));
32763 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32764
32765 assertTrue(GrouperClientWs.mostRecentRequest,
32766 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32767 assertTrue(GrouperClientWs.mostRecentRequest,
32768 !GrouperClientWs.mostRecentRequest.contains("actions"));
32769 assertTrue(GrouperClientWs.mostRecentRequest,
32770 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32771 assertTrue(GrouperClientWs.mostRecentRequest,
32772 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32773 assertTrue(GrouperClientWs.mostRecentRequest,
32774 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32775 assertTrue(GrouperClientWs.mostRecentRequest,
32776 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32777 assertTrue(GrouperClientWs.mostRecentRequest,
32778 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32779 assertTrue(GrouperClientWs.mostRecentRequest,
32780 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32781 assertTrue(GrouperClientWs.mostRecentRequest,
32782 !GrouperClientWs.mostRecentRequest.contains("params"));
32783 assertTrue(GrouperClientWs.mostRecentRequest,
32784 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32785 assertTrue(GrouperClientWs.mostRecentRequest,
32786 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32787 assertFalse(GrouperClientWs.mostRecentRequest,
32788 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32789 assertFalse(GrouperClientWs.mostRecentRequest,
32790 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32791 assertTrue(GrouperClientWs.mostRecentRequest,
32792 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32793 assertTrue(GrouperClientWs.mostRecentRequest,
32794 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32795 assertTrue(GrouperClientWs.mostRecentRequest,
32796 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32797 assertTrue(GrouperClientWs.mostRecentRequest,
32798 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32799 assertTrue(GrouperClientWs.mostRecentRequest,
32800 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32801 assertTrue(GrouperClientWs.mostRecentRequest,
32802 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32803 assertTrue(GrouperClientWs.mostRecentRequest,
32804 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32805 assertFalse(GrouperClientWs.mostRecentRequest,
32806 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32807 assertFalse(GrouperClientWs.mostRecentRequest,
32808 GrouperClientWs.mostRecentRequest.contains("theValue"));
32809 assertFalse(GrouperClientWs.mostRecentRequest,
32810 GrouperClientWs.mostRecentRequest.contains(">123<"));
32811 assertFalse(GrouperClientWs.mostRecentRequest,
32812 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32813 assertFalse(GrouperClientWs.mostRecentRequest,
32814 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32815 assertTrue(GrouperClientWs.mostRecentRequest,
32816 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32817 assertTrue(GrouperClientWs.mostRecentRequest,
32818 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32819 assertTrue(GrouperClientWs.mostRecentRequest,
32820 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32821 assertTrue(GrouperClientWs.mostRecentRequest,
32822 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32823
32824
32825
32826
32827
32828
32829 baos = new ByteArrayOutputStream();
32830 System.setOut(new PrintStream(baos));
32831
32832 try {
32833 GrouperClient.main(GrouperClientUtils.splitTrim(
32834 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
32835 ,
32836 " "));
32837
32838 System.out.flush();
32839 output = new String(baos.toByteArray());
32840
32841 System.setOut(systemOut);
32842
32843 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32844
32845
32846
32847 pattern = Pattern
32848 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32849
32850 assertEquals(0, GrouperUtil.length(outputLines));
32851 fail("Shouldnt get here");
32852
32853 } catch (Exception e) {
32854
32855 } finally {
32856
32857 System.setOut(systemOut);
32858
32859 }
32860
32861 assertTrue(GrouperClientWs.mostRecentRequest,
32862 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32863 assertTrue(GrouperClientWs.mostRecentRequest,
32864 !GrouperClientWs.mostRecentRequest.contains("actions"));
32865 assertTrue(GrouperClientWs.mostRecentRequest,
32866 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32867 assertTrue(GrouperClientWs.mostRecentRequest,
32868 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32869 assertTrue(GrouperClientWs.mostRecentRequest,
32870 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32871 assertTrue(GrouperClientWs.mostRecentRequest,
32872 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32873 assertTrue(GrouperClientWs.mostRecentRequest,
32874 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32875 assertTrue(GrouperClientWs.mostRecentRequest,
32876 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32877 assertTrue(GrouperClientWs.mostRecentRequest,
32878 !GrouperClientWs.mostRecentRequest.contains("params"));
32879 assertTrue(GrouperClientWs.mostRecentRequest,
32880 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32881 assertTrue(GrouperClientWs.mostRecentRequest,
32882 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32883 assertFalse(GrouperClientWs.mostRecentRequest,
32884 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32885 assertFalse(GrouperClientWs.mostRecentRequest,
32886 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32887 assertTrue(GrouperClientWs.mostRecentRequest,
32888 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32889 assertTrue(GrouperClientWs.mostRecentRequest,
32890 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32891 assertTrue(GrouperClientWs.mostRecentRequest,
32892 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32893 assertTrue(GrouperClientWs.mostRecentRequest,
32894 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32895 assertTrue(GrouperClientWs.mostRecentRequest,
32896 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32897 assertTrue(GrouperClientWs.mostRecentRequest,
32898 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32899 assertTrue(GrouperClientWs.mostRecentRequest,
32900 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32901 assertFalse(GrouperClientWs.mostRecentRequest,
32902 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32903 assertFalse(GrouperClientWs.mostRecentRequest,
32904 GrouperClientWs.mostRecentRequest.contains("theValue"));
32905 assertFalse(GrouperClientWs.mostRecentRequest,
32906 GrouperClientWs.mostRecentRequest.contains(">123<"));
32907 assertFalse(GrouperClientWs.mostRecentRequest,
32908 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32909 assertFalse(GrouperClientWs.mostRecentRequest,
32910 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32911 assertTrue(GrouperClientWs.mostRecentRequest,
32912 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32913 assertTrue(GrouperClientWs.mostRecentRequest,
32914 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32915 assertTrue(GrouperClientWs.mostRecentRequest,
32916 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32917 assertTrue(GrouperClientWs.mostRecentRequest,
32918 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32919
32920
32921
32922
32923
32924 baos = new ByteArrayOutputStream();
32925 System.setOut(new PrintStream(baos));
32926
32927 GrouperClient.main(GrouperClientUtils.splitTrim(
32928 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
32929 ,
32930 " "));
32931
32932 System.out.flush();
32933 output = new String(baos.toByteArray());
32934
32935 System.setOut(systemOut);
32936
32937 outputLines = GrouperClientUtils.splitTrim(output, "\n");
32938
32939
32940
32941 pattern = Pattern
32942 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32943
32944 assertEquals(1, GrouperUtil.length(outputLines));
32945
32946 outputLine = outputLines[0];
32947
32948 matcher = pattern.matcher(outputLine);
32949
32950 assertTrue(outputLine, matcher.matches());
32951 assertEquals(outputLine, "0", matcher.group(1));
32952 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32953 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32954 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32955 assertEquals(outputLine, "assign", matcher.group(5));
32956 assertEquals(outputLine, "123", matcher.group(6));
32957 assertEquals(outputLine, "T", matcher.group(7));
32958 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32959
32960 assertTrue(GrouperClientWs.mostRecentRequest,
32961 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32962 assertTrue(GrouperClientWs.mostRecentRequest,
32963 !GrouperClientWs.mostRecentRequest.contains("actions"));
32964 assertTrue(GrouperClientWs.mostRecentRequest,
32965 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32966 assertTrue(GrouperClientWs.mostRecentRequest,
32967 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32968 assertTrue(GrouperClientWs.mostRecentRequest,
32969 !GrouperClientWs.mostRecentRequest.contains("enabled"));
32970 assertTrue(GrouperClientWs.mostRecentRequest,
32971 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32972 assertTrue(GrouperClientWs.mostRecentRequest,
32973 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32974 assertTrue(GrouperClientWs.mostRecentRequest,
32975 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32976 assertTrue(GrouperClientWs.mostRecentRequest,
32977 !GrouperClientWs.mostRecentRequest.contains("params"));
32978 assertTrue(GrouperClientWs.mostRecentRequest,
32979 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32980 assertTrue(GrouperClientWs.mostRecentRequest,
32981 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32982 assertFalse(GrouperClientWs.mostRecentRequest,
32983 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32984 assertTrue(GrouperClientWs.mostRecentRequest,
32985 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32986 assertTrue(GrouperClientWs.mostRecentRequest,
32987 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32988 assertTrue(GrouperClientWs.mostRecentRequest,
32989 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32990 assertTrue(GrouperClientWs.mostRecentRequest,
32991 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32992 assertTrue(GrouperClientWs.mostRecentRequest,
32993 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32994 assertTrue(GrouperClientWs.mostRecentRequest,
32995 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32996 assertTrue(GrouperClientWs.mostRecentRequest,
32997 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32998 assertTrue(GrouperClientWs.mostRecentRequest,
32999 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33000 assertFalse(GrouperClientWs.mostRecentRequest,
33001 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33002 assertFalse(GrouperClientWs.mostRecentRequest,
33003 GrouperClientWs.mostRecentRequest.contains("theValue"));
33004 assertFalse(GrouperClientWs.mostRecentRequest,
33005 GrouperClientWs.mostRecentRequest.contains(">123<"));
33006 assertFalse(GrouperClientWs.mostRecentRequest,
33007 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33008 assertFalse(GrouperClientWs.mostRecentRequest,
33009 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33010 assertTrue(GrouperClientWs.mostRecentRequest,
33011 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33012 assertTrue(GrouperClientWs.mostRecentRequest,
33013 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33014 assertTrue(GrouperClientWs.mostRecentRequest,
33015 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33016 assertTrue(GrouperClientWs.mostRecentRequest,
33017 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33018
33019
33020
33021
33022
33023
33024 baos = new ByteArrayOutputStream();
33025 System.setOut(new PrintStream(baos));
33026
33027 try {
33028 GrouperClient.main(GrouperClientUtils.splitTrim(
33029 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
33030 ,
33031 " "));
33032
33033 System.out.flush();
33034 output = new String(baos.toByteArray());
33035
33036 System.setOut(systemOut);
33037
33038 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33039
33040
33041
33042 pattern = Pattern
33043 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33044
33045 assertEquals(1, GrouperUtil.length(outputLines));
33046 fail("Shouldnt get here");
33047 } catch (Exception e) {
33048
33049 } finally {
33050
33051 System.setOut(systemOut);
33052
33053 }
33054
33055 assertTrue(GrouperClientWs.mostRecentRequest,
33056 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33057 assertTrue(GrouperClientWs.mostRecentRequest,
33058 !GrouperClientWs.mostRecentRequest.contains("actions"));
33059 assertTrue(GrouperClientWs.mostRecentRequest,
33060 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33061 assertTrue(GrouperClientWs.mostRecentRequest,
33062 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33063 assertTrue(GrouperClientWs.mostRecentRequest,
33064 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33065 assertTrue(GrouperClientWs.mostRecentRequest,
33066 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33067 assertTrue(GrouperClientWs.mostRecentRequest,
33068 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33069 assertTrue(GrouperClientWs.mostRecentRequest,
33070 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33071 assertTrue(GrouperClientWs.mostRecentRequest,
33072 !GrouperClientWs.mostRecentRequest.contains("params"));
33073 assertTrue(GrouperClientWs.mostRecentRequest,
33074 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33075 assertTrue(GrouperClientWs.mostRecentRequest,
33076 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33077 assertFalse(GrouperClientWs.mostRecentRequest,
33078 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33079 assertTrue(GrouperClientWs.mostRecentRequest,
33080 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33081 assertTrue(GrouperClientWs.mostRecentRequest,
33082 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33083 assertTrue(GrouperClientWs.mostRecentRequest,
33084 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33085 assertTrue(GrouperClientWs.mostRecentRequest,
33086 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33087 assertTrue(GrouperClientWs.mostRecentRequest,
33088 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33089 assertTrue(GrouperClientWs.mostRecentRequest,
33090 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33091 assertTrue(GrouperClientWs.mostRecentRequest,
33092 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33093 assertTrue(GrouperClientWs.mostRecentRequest,
33094 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33095 assertFalse(GrouperClientWs.mostRecentRequest,
33096 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33097 assertFalse(GrouperClientWs.mostRecentRequest,
33098 GrouperClientWs.mostRecentRequest.contains("theValue"));
33099 assertFalse(GrouperClientWs.mostRecentRequest,
33100 GrouperClientWs.mostRecentRequest.contains(">123<"));
33101 assertFalse(GrouperClientWs.mostRecentRequest,
33102 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33103 assertFalse(GrouperClientWs.mostRecentRequest,
33104 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33105 assertTrue(GrouperClientWs.mostRecentRequest,
33106 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33107 assertTrue(GrouperClientWs.mostRecentRequest,
33108 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33109 assertTrue(GrouperClientWs.mostRecentRequest,
33110 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33111 assertTrue(GrouperClientWs.mostRecentRequest,
33112 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33113
33114
33115
33116
33117
33118 baos = new ByteArrayOutputStream();
33119 System.setOut(new PrintStream(baos));
33120
33121 GrouperClient.main(GrouperClientUtils.splitTrim(
33122 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
33123 + " --assignAssignOwnerActions=assign",
33124 " "));
33125
33126 System.out.flush();
33127 output = new String(baos.toByteArray());
33128
33129 System.setOut(systemOut);
33130
33131 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33132
33133
33134
33135 pattern = Pattern
33136 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33137
33138 assertEquals(1, GrouperUtil.length(outputLines));
33139
33140 outputLine = outputLines[0];
33141
33142 matcher = pattern.matcher(outputLine);
33143
33144 assertTrue(outputLine, matcher.matches());
33145 assertEquals(outputLine, "0", matcher.group(1));
33146 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
33147 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33148 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33149 assertEquals(outputLine, "assign", matcher.group(5));
33150 assertEquals(outputLine, "123", matcher.group(6));
33151 assertEquals(outputLine, "T", matcher.group(7));
33152 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33153
33154 assertTrue(GrouperClientWs.mostRecentRequest,
33155 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33156 assertTrue(GrouperClientWs.mostRecentRequest,
33157 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
33158 assertTrue(GrouperClientWs.mostRecentRequest,
33159 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33160 assertTrue(GrouperClientWs.mostRecentRequest,
33161 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33162 assertTrue(GrouperClientWs.mostRecentRequest,
33163 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33164 assertTrue(GrouperClientWs.mostRecentRequest,
33165 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33166 assertTrue(GrouperClientWs.mostRecentRequest,
33167 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33168 assertTrue(GrouperClientWs.mostRecentRequest,
33169 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33170 assertTrue(GrouperClientWs.mostRecentRequest,
33171 !GrouperClientWs.mostRecentRequest.contains("params"));
33172 assertTrue(GrouperClientWs.mostRecentRequest,
33173 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33174 assertTrue(GrouperClientWs.mostRecentRequest,
33175 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33176 assertFalse(GrouperClientWs.mostRecentRequest,
33177 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33178 assertTrue(GrouperClientWs.mostRecentRequest,
33179 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33180 assertTrue(GrouperClientWs.mostRecentRequest,
33181 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33182 assertTrue(GrouperClientWs.mostRecentRequest,
33183 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33184 assertTrue(GrouperClientWs.mostRecentRequest,
33185 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33186 assertTrue(GrouperClientWs.mostRecentRequest,
33187 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33188 assertTrue(GrouperClientWs.mostRecentRequest,
33189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33190 assertTrue(GrouperClientWs.mostRecentRequest,
33191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33192 assertTrue(GrouperClientWs.mostRecentRequest,
33193 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33194 assertFalse(GrouperClientWs.mostRecentRequest,
33195 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33196 assertFalse(GrouperClientWs.mostRecentRequest,
33197 GrouperClientWs.mostRecentRequest.contains("theValue"));
33198 assertFalse(GrouperClientWs.mostRecentRequest,
33199 GrouperClientWs.mostRecentRequest.contains(">123<"));
33200 assertFalse(GrouperClientWs.mostRecentRequest,
33201 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33202 assertFalse(GrouperClientWs.mostRecentRequest,
33203 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33204 assertTrue(GrouperClientWs.mostRecentRequest,
33205 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33206 assertTrue(GrouperClientWs.mostRecentRequest,
33207 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33208 assertTrue(GrouperClientWs.mostRecentRequest,
33209 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33210 assertTrue(GrouperClientWs.mostRecentRequest,
33211 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
33212
33213
33214
33215
33216
33217 baos = new ByteArrayOutputStream();
33218 System.setOut(new PrintStream(baos));
33219
33220 GrouperClient.main(GrouperClientUtils.splitTrim(
33221 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
33222 + " --assignAssignOwnerActions=assign2",
33223 " "));
33224
33225 System.out.flush();
33226 output = new String(baos.toByteArray());
33227
33228 System.setOut(systemOut);
33229
33230 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33231
33232
33233
33234 pattern = Pattern
33235 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33236
33237 assertEquals(0, GrouperUtil.length(outputLines));
33238
33239 assertTrue(GrouperClientWs.mostRecentRequest,
33240 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33241 assertTrue(GrouperClientWs.mostRecentRequest,
33242 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
33243 assertTrue(GrouperClientWs.mostRecentRequest,
33244 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33245 assertTrue(GrouperClientWs.mostRecentRequest,
33246 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33247 assertTrue(GrouperClientWs.mostRecentRequest,
33248 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33249 assertTrue(GrouperClientWs.mostRecentRequest,
33250 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33251 assertTrue(GrouperClientWs.mostRecentRequest,
33252 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33253 assertTrue(GrouperClientWs.mostRecentRequest,
33254 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33255 assertTrue(GrouperClientWs.mostRecentRequest,
33256 !GrouperClientWs.mostRecentRequest.contains("params"));
33257 assertTrue(GrouperClientWs.mostRecentRequest,
33258 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33259 assertTrue(GrouperClientWs.mostRecentRequest,
33260 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33261 assertFalse(GrouperClientWs.mostRecentRequest,
33262 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33263 assertTrue(GrouperClientWs.mostRecentRequest,
33264 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33265 assertTrue(GrouperClientWs.mostRecentRequest,
33266 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33267 assertTrue(GrouperClientWs.mostRecentRequest,
33268 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33269 assertTrue(GrouperClientWs.mostRecentRequest,
33270 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33271 assertTrue(GrouperClientWs.mostRecentRequest,
33272 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33273 assertTrue(GrouperClientWs.mostRecentRequest,
33274 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33275 assertTrue(GrouperClientWs.mostRecentRequest,
33276 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33277 assertTrue(GrouperClientWs.mostRecentRequest,
33278 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33279 assertFalse(GrouperClientWs.mostRecentRequest,
33280 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33281 assertFalse(GrouperClientWs.mostRecentRequest,
33282 GrouperClientWs.mostRecentRequest.contains("theValue"));
33283 assertFalse(GrouperClientWs.mostRecentRequest,
33284 GrouperClientWs.mostRecentRequest.contains(">123<"));
33285 assertFalse(GrouperClientWs.mostRecentRequest,
33286 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33287 assertFalse(GrouperClientWs.mostRecentRequest,
33288 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33289 assertTrue(GrouperClientWs.mostRecentRequest,
33290 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33291 assertTrue(GrouperClientWs.mostRecentRequest,
33292 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33293 assertTrue(GrouperClientWs.mostRecentRequest,
33294 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33295 assertTrue(GrouperClientWs.mostRecentRequest,
33296 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
33297
33298
33299
33300
33301
33302
33303 baos = new ByteArrayOutputStream();
33304 System.setOut(new PrintStream(baos));
33305
33306 GrouperClient.main(GrouperClientUtils.splitTrim(
33307 "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --ownerMembershipUuids=" + membership.getImmediateMembershipId()
33308 ,
33309 " "));
33310
33311 System.out.flush();
33312 output = new String(baos.toByteArray());
33313
33314 System.setOut(systemOut);
33315
33316 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33317
33318
33319
33320 pattern = Pattern
33321 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33322
33323 assertEquals(1, GrouperUtil.length(outputLines));
33324
33325 outputLine = outputLines[0];
33326
33327 matcher = pattern.matcher(outputLine);
33328
33329 assertTrue(outputLine, matcher.matches());
33330 assertEquals(outputLine, "0", matcher.group(1));
33331 assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
33332 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33333 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33334 assertEquals(outputLine, "assign", matcher.group(5));
33335 assertEquals(outputLine, "123", matcher.group(6));
33336 assertEquals(outputLine, "T", matcher.group(7));
33337 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33338
33339 assertTrue(GrouperClientWs.mostRecentRequest,
33340 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33341 assertTrue(GrouperClientWs.mostRecentRequest,
33342 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
33343 assertTrue(GrouperClientWs.mostRecentRequest,
33344 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33345 assertTrue(GrouperClientWs.mostRecentRequest,
33346 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33347 assertTrue(GrouperClientWs.mostRecentRequest,
33348 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33349 assertTrue(GrouperClientWs.mostRecentRequest,
33350 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33351 assertTrue(GrouperClientWs.mostRecentRequest,
33352 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33353 assertTrue(GrouperClientWs.mostRecentRequest,
33354 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33355 assertTrue(GrouperClientWs.mostRecentRequest,
33356 !GrouperClientWs.mostRecentRequest.contains("params"));
33357 assertTrue(GrouperClientWs.mostRecentRequest,
33358 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33359 assertTrue(GrouperClientWs.mostRecentRequest,
33360 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33361 assertFalse(GrouperClientWs.mostRecentRequest,
33362 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33363 assertTrue(GrouperClientWs.mostRecentRequest,
33364 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33365 assertTrue(GrouperClientWs.mostRecentRequest,
33366 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33367 assertTrue(GrouperClientWs.mostRecentRequest,
33368 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33369 assertTrue(GrouperClientWs.mostRecentRequest,
33370 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33371 assertTrue(GrouperClientWs.mostRecentRequest,
33372 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33373 assertTrue(GrouperClientWs.mostRecentRequest,
33374 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33375 assertTrue(GrouperClientWs.mostRecentRequest,
33376 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33377 assertTrue(GrouperClientWs.mostRecentRequest,
33378 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33379 assertFalse(GrouperClientWs.mostRecentRequest,
33380 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33381 assertFalse(GrouperClientWs.mostRecentRequest,
33382 GrouperClientWs.mostRecentRequest.contains("theValue"));
33383 assertFalse(GrouperClientWs.mostRecentRequest,
33384 GrouperClientWs.mostRecentRequest.contains(">123<"));
33385 assertFalse(GrouperClientWs.mostRecentRequest,
33386 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33387 assertFalse(GrouperClientWs.mostRecentRequest,
33388 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33389 assertTrue(GrouperClientWs.mostRecentRequest,
33390 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33391 assertTrue(GrouperClientWs.mostRecentRequest,
33392 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33393 assertTrue(GrouperClientWs.mostRecentRequest,
33394 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33395 assertTrue(GrouperClientWs.mostRecentRequest,
33396 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
33397
33398
33399 } finally {
33400 System.setOut(systemOut);
33401 }
33402
33403 }
33404
33405
33406
33407
33408 public void testGetAttributeAssignsAnyMembershipExtraFeatures() throws Exception {
33409
33410 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
33411 AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
33412
33413 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
33414
33415 attributeDef.setValueType(AttributeDefValueType.string);
33416 attributeDef.setAssignToGroup(false);
33417 attributeDef.setAssignToEffMembership(true);
33418 attributeDef.store();
33419
33420 final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
33421
33422 attributeDef2.setAssignToGroup(false);
33423 attributeDef2.setAssignToEffMembershipAssn(true);
33424 attributeDef2.setValueType(AttributeDefValueType.integer);
33425 attributeDef2.store();
33426
33427 Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
33428 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
33429 .assignDescription("description").save();
33430
33431 Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
33432 .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
33433 .assignDescription("description").save();
33434
33435
33436 group1.addMember(group2.toSubject());
33437 group2.addMember(SubjectTestHelper.SUBJ0);
33438
33439 Member member = MemberFinder.findBySubject(GrouperSession.staticGrouperSession(), SubjectTestHelper.SUBJ0, false);
33440
33441 Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
33442 GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
33443
33444 AttributeAssignResult attributeAssignResult = membership.getAttributeDelegateEffMship().assignAttribute(attributeDefName);
33445
33446 AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
33447 attributeAssign.getValueDelegate().assignValue("abc");
33448
33449 AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
33450 AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
33451 attributeAssign2.getValueDelegate().assignValue("123");
33452
33453 PrintStream systemOut = System.out;
33454
33455 ByteArrayOutputStream baos = new ByteArrayOutputStream();
33456 System.setOut(new PrintStream(baos));
33457
33458 try {
33459
33460 GrouperClient.main(GrouperClientUtils.splitTrim(
33461 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem " +
33462 "--attributeDefNames=test:testAttributeAssignDefNameDef " +
33463 "--attributeDefValueType=string --value=abc",
33464 " "));
33465 System.out.flush();
33466 String output = new String(baos.toByteArray());
33467
33468 System.setOut(systemOut);
33469
33470 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
33471
33472
33473
33474 Pattern pattern = Pattern
33475 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33476
33477 assertEquals(1, GrouperUtil.length(outputLines));
33478 String outputLine = outputLines[0];
33479
33480 Matcher matcher = pattern.matcher(outputLines[0]);
33481
33482 assertTrue(outputLine, matcher.matches());
33483 assertEquals(outputLine, "0", matcher.group(1));
33484 assertEquals(outputLine, "any_mem", matcher.group(2));
33485 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
33486 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
33487 assertEquals(outputLine, "assign", matcher.group(5));
33488 assertEquals(outputLine, "abc", matcher.group(6));
33489 assertEquals(outputLine, "T", matcher.group(7));
33490 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
33491
33492 assertTrue(GrouperClientWs.mostRecentRequest,
33493 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33494 assertTrue(GrouperClientWs.mostRecentRequest,
33495 !GrouperClientWs.mostRecentRequest.contains("actions"));
33496 assertTrue(GrouperClientWs.mostRecentRequest,
33497 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33498 assertTrue(GrouperClientWs.mostRecentRequest,
33499 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33500 assertTrue(GrouperClientWs.mostRecentRequest,
33501 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33502 assertTrue(GrouperClientWs.mostRecentRequest,
33503 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33504 assertTrue(GrouperClientWs.mostRecentRequest,
33505 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33506 assertTrue(GrouperClientWs.mostRecentRequest,
33507 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33508 assertTrue(GrouperClientWs.mostRecentRequest,
33509 !GrouperClientWs.mostRecentRequest.contains("params"));
33510 assertTrue(GrouperClientWs.mostRecentRequest,
33511 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33512 assertTrue(GrouperClientWs.mostRecentRequest,
33513 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33514 assertTrue(GrouperClientWs.mostRecentRequest,
33515 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
33516 assertTrue(GrouperClientWs.mostRecentRequest,
33517 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33518 assertTrue(GrouperClientWs.mostRecentRequest,
33519 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33520 assertTrue(GrouperClientWs.mostRecentRequest,
33521 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33522 assertTrue(GrouperClientWs.mostRecentRequest,
33523 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33524 assertTrue(GrouperClientWs.mostRecentRequest,
33525 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33526 assertTrue(GrouperClientWs.mostRecentRequest,
33527 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33528 assertTrue(GrouperClientWs.mostRecentRequest,
33529 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33530 assertTrue(GrouperClientWs.mostRecentRequest,
33531 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33532 assertTrue(GrouperClientWs.mostRecentRequest,
33533 GrouperClientWs.mostRecentRequest.contains("theValue"));
33534 assertTrue(GrouperClientWs.mostRecentRequest,
33535 GrouperClientWs.mostRecentRequest.contains("abc"));
33536 assertTrue(GrouperClientWs.mostRecentRequest,
33537 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33538 assertTrue(GrouperClientWs.mostRecentRequest,
33539 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33540 assertTrue(GrouperClientWs.mostRecentRequest,
33541 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33542 assertTrue(GrouperClientWs.mostRecentRequest,
33543 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33544 assertTrue(GrouperClientWs.mostRecentRequest,
33545 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33546 assertTrue(GrouperClientWs.mostRecentRequest,
33547 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33548 assertTrue(GrouperClientWs.mostRecentRequest,
33549 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33550 assertTrue(GrouperClientWs.mostRecentRequest,
33551 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33552
33553
33554
33555
33556 baos = new ByteArrayOutputStream();
33557 System.setOut(new PrintStream(baos));
33558
33559 GrouperClient.main(GrouperClientUtils.splitTrim(
33560 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=" + attributeDef.getId() +
33561 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
33562 "--attributeDefValueType=string --value=123",
33563 " "));
33564
33565
33566 System.out.flush();
33567 output = new String(baos.toByteArray());
33568
33569 System.setOut(systemOut);
33570
33571 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33572
33573 assertEquals(0, GrouperUtil.length(outputLines));
33574
33575
33576
33577
33578 assertTrue(GrouperClientWs.mostRecentRequest,
33579 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33580 assertTrue(GrouperClientWs.mostRecentRequest,
33581 !GrouperClientWs.mostRecentRequest.contains("actions"));
33582 assertTrue(GrouperClientWs.mostRecentRequest,
33583 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33584 assertTrue(GrouperClientWs.mostRecentRequest,
33585 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33586 assertTrue(GrouperClientWs.mostRecentRequest,
33587 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33588 assertTrue(GrouperClientWs.mostRecentRequest,
33589 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33590 assertTrue(GrouperClientWs.mostRecentRequest,
33591 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33592 assertTrue(GrouperClientWs.mostRecentRequest,
33593 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33594 assertTrue(GrouperClientWs.mostRecentRequest,
33595 !GrouperClientWs.mostRecentRequest.contains("params"));
33596 assertTrue(GrouperClientWs.mostRecentRequest,
33597 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33598 assertTrue(GrouperClientWs.mostRecentRequest,
33599 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33600 assertTrue(GrouperClientWs.mostRecentRequest,
33601 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
33602 assertTrue(GrouperClientWs.mostRecentRequest,
33603 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33604 assertTrue(GrouperClientWs.mostRecentRequest,
33605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33606 assertTrue(GrouperClientWs.mostRecentRequest,
33607 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33608 assertTrue(GrouperClientWs.mostRecentRequest,
33609 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33610 assertTrue(GrouperClientWs.mostRecentRequest,
33611 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33612 assertTrue(GrouperClientWs.mostRecentRequest,
33613 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33614 assertTrue(GrouperClientWs.mostRecentRequest,
33615 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33616 assertTrue(GrouperClientWs.mostRecentRequest,
33617 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33618 assertTrue(GrouperClientWs.mostRecentRequest,
33619 GrouperClientWs.mostRecentRequest.contains("theValue"));
33620 assertTrue(GrouperClientWs.mostRecentRequest,
33621 GrouperClientWs.mostRecentRequest.contains(">123<"));
33622 assertTrue(GrouperClientWs.mostRecentRequest,
33623 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33624 assertTrue(GrouperClientWs.mostRecentRequest,
33625 !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33626 assertTrue(GrouperClientWs.mostRecentRequest,
33627 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33628 assertTrue(GrouperClientWs.mostRecentRequest,
33629 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33630 assertTrue(GrouperClientWs.mostRecentRequest,
33631 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33632 assertTrue(GrouperClientWs.mostRecentRequest,
33633 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33634 assertTrue(GrouperClientWs.mostRecentRequest,
33635 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33636 assertTrue(GrouperClientWs.mostRecentRequest,
33637 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33638
33639
33640
33641
33642
33643 baos = new ByteArrayOutputStream();
33644 System.setOut(new PrintStream(baos));
33645
33646 try {
33647 GrouperClient.main(GrouperClientUtils.splitTrim(
33648 " --operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=123" + attributeDef.getId() +
33649 " --attributeDefNames=test:testAttributeAssignDefNameDef " +
33650 "--attributeDefValueType=string --value=123",
33651 " "));
33652 fail("Shouldnt get here");
33653 } catch (GcWebServiceError gwse) {
33654
33655 }
33656
33657
33658
33659
33660 baos = new ByteArrayOutputStream();
33661 System.setOut(new PrintStream(baos));
33662
33663 GrouperClient.main(GrouperClientUtils.splitTrim(
33664 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=" + attributeDef.getId() +
33665 " --attributeDefValueType=string --value=abc --attributeDefType=attr",
33666 " "));
33667
33668
33669 System.out.flush();
33670 output = new String(baos.toByteArray());
33671
33672 System.setOut(systemOut);
33673
33674 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33675
33676
33677
33678 pattern = Pattern
33679 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33680
33681 assertEquals(1, GrouperUtil.length(outputLines));
33682 outputLine = outputLines[0];
33683
33684 matcher = pattern.matcher(outputLines[0]);
33685
33686 assertTrue(outputLine, matcher.matches());
33687 assertEquals(outputLine, "0", matcher.group(1));
33688 assertEquals(outputLine, "any_mem", matcher.group(2));
33689 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
33690 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
33691 assertEquals(outputLine, "assign", matcher.group(5));
33692 assertEquals(outputLine, "abc", matcher.group(6));
33693 assertEquals(outputLine, "T", matcher.group(7));
33694 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
33695
33696 assertTrue(GrouperClientWs.mostRecentRequest,
33697 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33698 assertTrue(GrouperClientWs.mostRecentRequest,
33699 !GrouperClientWs.mostRecentRequest.contains("actions"));
33700 assertTrue(GrouperClientWs.mostRecentRequest,
33701 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33702 assertTrue(GrouperClientWs.mostRecentRequest,
33703 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33704 assertTrue(GrouperClientWs.mostRecentRequest,
33705 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33706 assertTrue(GrouperClientWs.mostRecentRequest,
33707 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33708 assertTrue(GrouperClientWs.mostRecentRequest,
33709 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33710 assertTrue(GrouperClientWs.mostRecentRequest,
33711 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33712 assertTrue(GrouperClientWs.mostRecentRequest,
33713 !GrouperClientWs.mostRecentRequest.contains("params"));
33714 assertTrue(GrouperClientWs.mostRecentRequest,
33715 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33716 assertTrue(GrouperClientWs.mostRecentRequest,
33717 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33718 assertTrue(GrouperClientWs.mostRecentRequest,
33719 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33720 assertTrue(GrouperClientWs.mostRecentRequest,
33721 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33722 assertTrue(GrouperClientWs.mostRecentRequest,
33723 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33724 assertTrue(GrouperClientWs.mostRecentRequest,
33725 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33726 assertTrue(GrouperClientWs.mostRecentRequest,
33727 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33728 assertTrue(GrouperClientWs.mostRecentRequest,
33729 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33730 assertTrue(GrouperClientWs.mostRecentRequest,
33731 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33732 assertTrue(GrouperClientWs.mostRecentRequest,
33733 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33734 assertTrue(GrouperClientWs.mostRecentRequest,
33735 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33736 assertTrue(GrouperClientWs.mostRecentRequest,
33737 GrouperClientWs.mostRecentRequest.contains("theValue"));
33738 assertTrue(GrouperClientWs.mostRecentRequest,
33739 GrouperClientWs.mostRecentRequest.contains("abc"));
33740 assertTrue(GrouperClientWs.mostRecentRequest,
33741 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33742 assertTrue(GrouperClientWs.mostRecentRequest,
33743 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33744 assertTrue(GrouperClientWs.mostRecentRequest,
33745 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33746 assertTrue(GrouperClientWs.mostRecentRequest,
33747 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33748 assertTrue(GrouperClientWs.mostRecentRequest,
33749 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33750 assertTrue(GrouperClientWs.mostRecentRequest,
33751 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33752 assertTrue(GrouperClientWs.mostRecentRequest,
33753 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33754 assertTrue(GrouperClientWs.mostRecentRequest,
33755 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33756
33757
33758
33759
33760 baos = new ByteArrayOutputStream();
33761 System.setOut(new PrintStream(baos));
33762
33763 GrouperClient.main(GrouperClientUtils.splitTrim(
33764 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=" + attributeDef.getId() +
33765 " --attributeDefValueType=string --value=abc --attributeDefType=limit",
33766 " "));
33767
33768 System.out.flush();
33769 output = new String(baos.toByteArray());
33770
33771 System.setOut(systemOut);
33772
33773 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33774
33775
33776
33777 pattern = Pattern
33778 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33779
33780 assertEquals(0, GrouperUtil.length(outputLines));
33781
33782 assertTrue(GrouperClientWs.mostRecentRequest,
33783 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33784 assertTrue(GrouperClientWs.mostRecentRequest,
33785 !GrouperClientWs.mostRecentRequest.contains("actions"));
33786 assertTrue(GrouperClientWs.mostRecentRequest,
33787 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33788 assertTrue(GrouperClientWs.mostRecentRequest,
33789 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33790 assertTrue(GrouperClientWs.mostRecentRequest,
33791 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33792 assertTrue(GrouperClientWs.mostRecentRequest,
33793 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33794 assertTrue(GrouperClientWs.mostRecentRequest,
33795 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33796 assertTrue(GrouperClientWs.mostRecentRequest,
33797 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33798 assertTrue(GrouperClientWs.mostRecentRequest,
33799 !GrouperClientWs.mostRecentRequest.contains("params"));
33800 assertTrue(GrouperClientWs.mostRecentRequest,
33801 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33802 assertTrue(GrouperClientWs.mostRecentRequest,
33803 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33804 assertTrue(GrouperClientWs.mostRecentRequest,
33805 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33806 assertTrue(GrouperClientWs.mostRecentRequest,
33807 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33808 assertTrue(GrouperClientWs.mostRecentRequest,
33809 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33810 assertTrue(GrouperClientWs.mostRecentRequest,
33811 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33812 assertTrue(GrouperClientWs.mostRecentRequest,
33813 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33814 assertTrue(GrouperClientWs.mostRecentRequest,
33815 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33816 assertTrue(GrouperClientWs.mostRecentRequest,
33817 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33818 assertTrue(GrouperClientWs.mostRecentRequest,
33819 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33820 assertTrue(GrouperClientWs.mostRecentRequest,
33821 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33822 assertTrue(GrouperClientWs.mostRecentRequest,
33823 GrouperClientWs.mostRecentRequest.contains("theValue"));
33824 assertTrue(GrouperClientWs.mostRecentRequest,
33825 GrouperClientWs.mostRecentRequest.contains("abc"));
33826 assertTrue(GrouperClientWs.mostRecentRequest,
33827 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33828 assertTrue(GrouperClientWs.mostRecentRequest,
33829 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33830 assertTrue(GrouperClientWs.mostRecentRequest,
33831 GrouperClientWs.mostRecentRequest.contains("limit"));
33832 assertTrue(GrouperClientWs.mostRecentRequest,
33833 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33834 assertTrue(GrouperClientWs.mostRecentRequest,
33835 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33836 assertTrue(GrouperClientWs.mostRecentRequest,
33837 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33838 assertTrue(GrouperClientWs.mostRecentRequest,
33839 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33840 assertTrue(GrouperClientWs.mostRecentRequest,
33841 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33842 assertTrue(GrouperClientWs.mostRecentRequest,
33843 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33844
33845
33846
33847
33848 baos = new ByteArrayOutputStream();
33849 System.setOut(new PrintStream(baos));
33850
33851 GrouperClient.main(GrouperClientUtils.splitTrim(
33852 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId(),
33853 " "));
33854
33855 System.out.flush();
33856 output = new String(baos.toByteArray());
33857
33858 System.setOut(systemOut);
33859
33860 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33861
33862
33863
33864 pattern = Pattern
33865 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33866
33867 assertEquals(1, GrouperUtil.length(outputLines));
33868 outputLine = outputLines[0];
33869
33870 matcher = pattern.matcher(outputLines[0]);
33871
33872 assertTrue(outputLine, matcher.matches());
33873 assertEquals(outputLine, "0", matcher.group(1));
33874 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
33875 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33876 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33877 assertEquals(outputLine, "assign", matcher.group(5));
33878 assertEquals(outputLine, "123", matcher.group(6));
33879 assertEquals(outputLine, "T", matcher.group(7));
33880 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33881
33882 assertTrue(GrouperClientWs.mostRecentRequest,
33883 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33884 assertTrue(GrouperClientWs.mostRecentRequest,
33885 !GrouperClientWs.mostRecentRequest.contains("actions"));
33886 assertTrue(GrouperClientWs.mostRecentRequest,
33887 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33888 assertTrue(GrouperClientWs.mostRecentRequest,
33889 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33890 assertTrue(GrouperClientWs.mostRecentRequest,
33891 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33892 assertTrue(GrouperClientWs.mostRecentRequest,
33893 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33894 assertTrue(GrouperClientWs.mostRecentRequest,
33895 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33896 assertTrue(GrouperClientWs.mostRecentRequest,
33897 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33898 assertTrue(GrouperClientWs.mostRecentRequest,
33899 !GrouperClientWs.mostRecentRequest.contains("params"));
33900 assertTrue(GrouperClientWs.mostRecentRequest,
33901 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33902 assertTrue(GrouperClientWs.mostRecentRequest,
33903 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33904 assertTrue(GrouperClientWs.mostRecentRequest,
33905 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33906 assertTrue(GrouperClientWs.mostRecentRequest,
33907 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33908 assertTrue(GrouperClientWs.mostRecentRequest,
33909 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33910 assertTrue(GrouperClientWs.mostRecentRequest,
33911 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33912 assertTrue(GrouperClientWs.mostRecentRequest,
33913 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33914 assertTrue(GrouperClientWs.mostRecentRequest,
33915 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33916 assertTrue(GrouperClientWs.mostRecentRequest,
33917 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33918 assertTrue(GrouperClientWs.mostRecentRequest,
33919 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33920 assertFalse(GrouperClientWs.mostRecentRequest,
33921 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33922 assertFalse(GrouperClientWs.mostRecentRequest,
33923 GrouperClientWs.mostRecentRequest.contains("theValue"));
33924 assertFalse(GrouperClientWs.mostRecentRequest,
33925 GrouperClientWs.mostRecentRequest.contains(">abc<"));
33926 assertTrue(GrouperClientWs.mostRecentRequest,
33927 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33928 assertFalse(GrouperClientWs.mostRecentRequest,
33929 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33930 assertTrue(GrouperClientWs.mostRecentRequest,
33931 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33932 assertTrue(GrouperClientWs.mostRecentRequest,
33933 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33934 assertTrue(GrouperClientWs.mostRecentRequest,
33935 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33936 assertTrue(GrouperClientWs.mostRecentRequest,
33937 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33938 assertTrue(GrouperClientWs.mostRecentRequest,
33939 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33940 assertTrue(GrouperClientWs.mostRecentRequest,
33941 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33942
33943
33944
33945
33946
33947 baos = new ByteArrayOutputStream();
33948 System.setOut(new PrintStream(baos));
33949
33950 GrouperClient.main(GrouperClientUtils.splitTrim(
33951 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefIdIndexes=" + attributeDef2.getIdIndex(),
33952 " "));
33953
33954 System.out.flush();
33955 output = new String(baos.toByteArray());
33956
33957 System.setOut(systemOut);
33958
33959 outputLines = GrouperClientUtils.splitTrim(output, "\n");
33960
33961
33962
33963 pattern = Pattern
33964 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33965
33966 assertEquals(1, GrouperUtil.length(outputLines));
33967 outputLine = outputLines[0];
33968
33969 matcher = pattern.matcher(outputLines[0]);
33970
33971 assertTrue(outputLine, matcher.matches());
33972 assertEquals(outputLine, "0", matcher.group(1));
33973 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
33974 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33975 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33976 assertEquals(outputLine, "assign", matcher.group(5));
33977 assertEquals(outputLine, "123", matcher.group(6));
33978 assertEquals(outputLine, "T", matcher.group(7));
33979 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33980
33981 assertTrue(GrouperClientWs.mostRecentRequest,
33982 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33983 assertTrue(GrouperClientWs.mostRecentRequest,
33984 !GrouperClientWs.mostRecentRequest.contains("actions"));
33985 assertTrue(GrouperClientWs.mostRecentRequest,
33986 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33987 assertTrue(GrouperClientWs.mostRecentRequest,
33988 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33989 assertTrue(GrouperClientWs.mostRecentRequest,
33990 !GrouperClientWs.mostRecentRequest.contains("enabled"));
33991 assertTrue(GrouperClientWs.mostRecentRequest,
33992 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33993 assertTrue(GrouperClientWs.mostRecentRequest,
33994 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33995 assertTrue(GrouperClientWs.mostRecentRequest,
33996 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33997 assertTrue(GrouperClientWs.mostRecentRequest,
33998 !GrouperClientWs.mostRecentRequest.contains("params"));
33999 assertTrue(GrouperClientWs.mostRecentRequest,
34000 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34001 assertTrue(GrouperClientWs.mostRecentRequest,
34002 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34003 assertTrue(GrouperClientWs.mostRecentRequest,
34004 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
34005 assertTrue(GrouperClientWs.mostRecentRequest,
34006 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34007 assertTrue(GrouperClientWs.mostRecentRequest,
34008 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34009 assertTrue(GrouperClientWs.mostRecentRequest,
34010 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34011 assertTrue(GrouperClientWs.mostRecentRequest,
34012 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34013 assertTrue(GrouperClientWs.mostRecentRequest,
34014 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34015 assertTrue(GrouperClientWs.mostRecentRequest,
34016 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34017 assertTrue(GrouperClientWs.mostRecentRequest,
34018 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34019 assertFalse(GrouperClientWs.mostRecentRequest,
34020 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34021 assertFalse(GrouperClientWs.mostRecentRequest,
34022 GrouperClientWs.mostRecentRequest.contains("theValue"));
34023 assertFalse(GrouperClientWs.mostRecentRequest,
34024 GrouperClientWs.mostRecentRequest.contains(">abc<"));
34025 assertTrue(GrouperClientWs.mostRecentRequest,
34026 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34027 assertFalse(GrouperClientWs.mostRecentRequest,
34028 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34029 assertTrue(GrouperClientWs.mostRecentRequest,
34030 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34031 assertTrue(GrouperClientWs.mostRecentRequest,
34032 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34033 assertTrue(GrouperClientWs.mostRecentRequest,
34034 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34035 assertTrue(GrouperClientWs.mostRecentRequest,
34036 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34037 assertTrue(GrouperClientWs.mostRecentRequest,
34038 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34039 assertTrue(GrouperClientWs.mostRecentRequest,
34040 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34041
34042
34043
34044
34045 baos = new ByteArrayOutputStream();
34046 System.setOut(new PrintStream(baos));
34047
34048 try {
34049 GrouperClient.main(GrouperClientUtils.splitTrim(
34050 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
34051 " "));
34052
34053 System.out.flush();
34054 output = new String(baos.toByteArray());
34055
34056 System.setOut(systemOut);
34057
34058 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34059
34060
34061
34062 pattern = Pattern
34063 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34064
34065 assertEquals(0, GrouperUtil.length(outputLines));
34066 fail("Why did it not fail?");
34067 } catch (Exception e) {
34068
34069 }
34070 assertTrue(GrouperClientWs.mostRecentRequest,
34071 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34072 assertTrue(GrouperClientWs.mostRecentRequest,
34073 !GrouperClientWs.mostRecentRequest.contains("actions"));
34074 assertTrue(GrouperClientWs.mostRecentRequest,
34075 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34076 assertTrue(GrouperClientWs.mostRecentRequest,
34077 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34078 assertTrue(GrouperClientWs.mostRecentRequest,
34079 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34080 assertTrue(GrouperClientWs.mostRecentRequest,
34081 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34082 assertTrue(GrouperClientWs.mostRecentRequest,
34083 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34084 assertTrue(GrouperClientWs.mostRecentRequest,
34085 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34086 assertTrue(GrouperClientWs.mostRecentRequest,
34087 !GrouperClientWs.mostRecentRequest.contains("params"));
34088 assertTrue(GrouperClientWs.mostRecentRequest,
34089 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34090 assertTrue(GrouperClientWs.mostRecentRequest,
34091 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34092 assertTrue(GrouperClientWs.mostRecentRequest,
34093 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34094 assertTrue(GrouperClientWs.mostRecentRequest,
34095 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34096 assertTrue(GrouperClientWs.mostRecentRequest,
34097 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34098 assertTrue(GrouperClientWs.mostRecentRequest,
34099 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34100 assertTrue(GrouperClientWs.mostRecentRequest,
34101 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34102 assertTrue(GrouperClientWs.mostRecentRequest,
34103 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34104 assertTrue(GrouperClientWs.mostRecentRequest,
34105 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34106 assertTrue(GrouperClientWs.mostRecentRequest,
34107 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34108 assertFalse(GrouperClientWs.mostRecentRequest,
34109 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34110 assertFalse(GrouperClientWs.mostRecentRequest,
34111 GrouperClientWs.mostRecentRequest.contains("theValue"));
34112 assertFalse(GrouperClientWs.mostRecentRequest,
34113 GrouperClientWs.mostRecentRequest.contains("abc"));
34114 assertTrue(GrouperClientWs.mostRecentRequest,
34115 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34116 assertFalse(GrouperClientWs.mostRecentRequest,
34117 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34118 assertTrue(GrouperClientWs.mostRecentRequest,
34119 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34120 assertTrue(GrouperClientWs.mostRecentRequest,
34121 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34122 assertTrue(GrouperClientWs.mostRecentRequest,
34123 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34124 assertTrue(GrouperClientWs.mostRecentRequest,
34125 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34126 assertTrue(GrouperClientWs.mostRecentRequest,
34127 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34128 assertTrue(GrouperClientWs.mostRecentRequest,
34129 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34130
34131
34132
34133
34134
34135 baos = new ByteArrayOutputStream();
34136 System.setOut(new PrintStream(baos));
34137
34138 GrouperClient.main(GrouperClientUtils.splitTrim(
34139 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
34140 + " --attributeDefValueType=integer --value=123 ",
34141 " "));
34142
34143 System.out.flush();
34144 output = new String(baos.toByteArray());
34145
34146 System.setOut(systemOut);
34147
34148 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34149
34150
34151
34152 pattern = Pattern
34153 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34154
34155 assertEquals(1, GrouperUtil.length(outputLines));
34156 outputLine = outputLines[0];
34157
34158 matcher = pattern.matcher(outputLines[0]);
34159
34160 assertTrue(outputLine, matcher.matches());
34161 assertEquals(outputLine, "0", matcher.group(1));
34162 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34163 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34164 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34165 assertEquals(outputLine, "assign", matcher.group(5));
34166 assertEquals(outputLine, "123", matcher.group(6));
34167 assertEquals(outputLine, "T", matcher.group(7));
34168 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34169
34170 assertTrue(GrouperClientWs.mostRecentRequest,
34171 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34172 assertTrue(GrouperClientWs.mostRecentRequest,
34173 !GrouperClientWs.mostRecentRequest.contains("actions"));
34174 assertTrue(GrouperClientWs.mostRecentRequest,
34175 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34176 assertTrue(GrouperClientWs.mostRecentRequest,
34177 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34178 assertTrue(GrouperClientWs.mostRecentRequest,
34179 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34180 assertTrue(GrouperClientWs.mostRecentRequest,
34181 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34182 assertTrue(GrouperClientWs.mostRecentRequest,
34183 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34184 assertTrue(GrouperClientWs.mostRecentRequest,
34185 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34186 assertTrue(GrouperClientWs.mostRecentRequest,
34187 !GrouperClientWs.mostRecentRequest.contains("params"));
34188 assertTrue(GrouperClientWs.mostRecentRequest,
34189 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34190 assertTrue(GrouperClientWs.mostRecentRequest,
34191 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34192 assertTrue(GrouperClientWs.mostRecentRequest,
34193 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34194 assertTrue(GrouperClientWs.mostRecentRequest,
34195 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34196 assertTrue(GrouperClientWs.mostRecentRequest,
34197 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34198 assertTrue(GrouperClientWs.mostRecentRequest,
34199 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34200 assertTrue(GrouperClientWs.mostRecentRequest,
34201 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34202 assertTrue(GrouperClientWs.mostRecentRequest,
34203 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34204 assertTrue(GrouperClientWs.mostRecentRequest,
34205 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34206 assertTrue(GrouperClientWs.mostRecentRequest,
34207 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34208 assertTrue(GrouperClientWs.mostRecentRequest,
34209 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34210 assertTrue(GrouperClientWs.mostRecentRequest,
34211 GrouperClientWs.mostRecentRequest.contains("theValue"));
34212 assertTrue(GrouperClientWs.mostRecentRequest,
34213 GrouperClientWs.mostRecentRequest.contains(">123<"));
34214 assertTrue(GrouperClientWs.mostRecentRequest,
34215 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34216 assertFalse(GrouperClientWs.mostRecentRequest,
34217 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34218 assertTrue(GrouperClientWs.mostRecentRequest,
34219 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34220 assertTrue(GrouperClientWs.mostRecentRequest,
34221 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34222 assertTrue(GrouperClientWs.mostRecentRequest,
34223 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34224 assertTrue(GrouperClientWs.mostRecentRequest,
34225 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34226 assertTrue(GrouperClientWs.mostRecentRequest,
34227 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34228 assertTrue(GrouperClientWs.mostRecentRequest,
34229 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34230
34231
34232
34233
34234
34235 baos = new ByteArrayOutputStream();
34236 System.setOut(new PrintStream(baos));
34237
34238 GrouperClient.main(GrouperClientUtils.splitTrim(
34239 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
34240 + " --attributeDefValueType=integer --value=1234 ",
34241 " "));
34242
34243 System.out.flush();
34244 output = new String(baos.toByteArray());
34245
34246 System.setOut(systemOut);
34247
34248 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34249
34250
34251
34252 pattern = Pattern
34253 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34254
34255 assertEquals(0, GrouperUtil.length(outputLines));
34256
34257 assertTrue(GrouperClientWs.mostRecentRequest,
34258 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34259 assertTrue(GrouperClientWs.mostRecentRequest,
34260 !GrouperClientWs.mostRecentRequest.contains("actions"));
34261 assertTrue(GrouperClientWs.mostRecentRequest,
34262 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34263 assertTrue(GrouperClientWs.mostRecentRequest,
34264 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34265 assertTrue(GrouperClientWs.mostRecentRequest,
34266 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34267 assertTrue(GrouperClientWs.mostRecentRequest,
34268 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34269 assertTrue(GrouperClientWs.mostRecentRequest,
34270 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34271 assertTrue(GrouperClientWs.mostRecentRequest,
34272 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34273 assertTrue(GrouperClientWs.mostRecentRequest,
34274 !GrouperClientWs.mostRecentRequest.contains("params"));
34275 assertTrue(GrouperClientWs.mostRecentRequest,
34276 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34277 assertTrue(GrouperClientWs.mostRecentRequest,
34278 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34279 assertTrue(GrouperClientWs.mostRecentRequest,
34280 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34281 assertTrue(GrouperClientWs.mostRecentRequest,
34282 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34283 assertTrue(GrouperClientWs.mostRecentRequest,
34284 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34285 assertTrue(GrouperClientWs.mostRecentRequest,
34286 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34287 assertTrue(GrouperClientWs.mostRecentRequest,
34288 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34289 assertTrue(GrouperClientWs.mostRecentRequest,
34290 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34291 assertTrue(GrouperClientWs.mostRecentRequest,
34292 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34293 assertTrue(GrouperClientWs.mostRecentRequest,
34294 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34295 assertTrue(GrouperClientWs.mostRecentRequest,
34296 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34297 assertTrue(GrouperClientWs.mostRecentRequest,
34298 GrouperClientWs.mostRecentRequest.contains("theValue"));
34299 assertTrue(GrouperClientWs.mostRecentRequest,
34300 GrouperClientWs.mostRecentRequest.contains("1234"));
34301 assertTrue(GrouperClientWs.mostRecentRequest,
34302 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34303 assertFalse(GrouperClientWs.mostRecentRequest,
34304 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34305 assertTrue(GrouperClientWs.mostRecentRequest,
34306 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34307 assertTrue(GrouperClientWs.mostRecentRequest,
34308 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34309 assertTrue(GrouperClientWs.mostRecentRequest,
34310 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34311 assertTrue(GrouperClientWs.mostRecentRequest,
34312 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34313 assertTrue(GrouperClientWs.mostRecentRequest,
34314 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34315 assertTrue(GrouperClientWs.mostRecentRequest,
34316 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34317
34318
34319
34320
34321
34322 baos = new ByteArrayOutputStream();
34323 System.setOut(new PrintStream(baos));
34324
34325 GrouperClient.main(GrouperClientUtils.splitTrim(
34326 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
34327 + " --includeAssignmentsFromAssignments=T ",
34328 " "));
34329
34330 System.out.flush();
34331 output = new String(baos.toByteArray());
34332
34333 System.setOut(systemOut);
34334
34335 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34336
34337
34338
34339 pattern = Pattern
34340 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34341
34342 assertEquals(2, GrouperUtil.length(outputLines));
34343 outputLine = outputLines[0];
34344
34345 matcher = pattern.matcher(outputLine);
34346
34347 assertTrue(outputLine, matcher.matches());
34348 assertEquals(outputLine, "0", matcher.group(1));
34349 assertEquals(outputLine, "any_mem", matcher.group(2));
34350 assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
34351 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
34352 assertEquals(outputLine, "assign", matcher.group(5));
34353 assertEquals(outputLine, "abc", matcher.group(6));
34354 assertEquals(outputLine, "T", matcher.group(7));
34355 assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
34356
34357 outputLine = outputLines[1];
34358
34359 matcher = pattern.matcher(outputLine);
34360
34361 assertTrue(outputLine, matcher.matches());
34362 assertEquals(outputLine, "1", matcher.group(1));
34363 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34364 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34365 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34366 assertEquals(outputLine, "assign", matcher.group(5));
34367 assertEquals(outputLine, "123", matcher.group(6));
34368 assertEquals(outputLine, "T", matcher.group(7));
34369 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34370
34371 assertTrue(GrouperClientWs.mostRecentRequest,
34372 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34373 assertTrue(GrouperClientWs.mostRecentRequest,
34374 !GrouperClientWs.mostRecentRequest.contains("actions"));
34375 assertTrue(GrouperClientWs.mostRecentRequest,
34376 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34377 assertTrue(GrouperClientWs.mostRecentRequest,
34378 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34379 assertTrue(GrouperClientWs.mostRecentRequest,
34380 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34381 assertTrue(GrouperClientWs.mostRecentRequest,
34382 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34383 assertTrue(GrouperClientWs.mostRecentRequest,
34384 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34385 assertTrue(GrouperClientWs.mostRecentRequest,
34386 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34387 assertTrue(GrouperClientWs.mostRecentRequest,
34388 !GrouperClientWs.mostRecentRequest.contains("params"));
34389 assertTrue(GrouperClientWs.mostRecentRequest,
34390 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34391 assertTrue(GrouperClientWs.mostRecentRequest,
34392 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34393 assertTrue(GrouperClientWs.mostRecentRequest,
34394 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34395 assertTrue(GrouperClientWs.mostRecentRequest,
34396 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34397 assertTrue(GrouperClientWs.mostRecentRequest,
34398 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34399 assertTrue(GrouperClientWs.mostRecentRequest,
34400 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34401 assertTrue(GrouperClientWs.mostRecentRequest,
34402 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34403 assertTrue(GrouperClientWs.mostRecentRequest,
34404 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34405 assertTrue(GrouperClientWs.mostRecentRequest,
34406 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34407 assertTrue(GrouperClientWs.mostRecentRequest,
34408 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34409 assertFalse(GrouperClientWs.mostRecentRequest,
34410 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34411 assertFalse(GrouperClientWs.mostRecentRequest,
34412 GrouperClientWs.mostRecentRequest.contains("theValue"));
34413 assertFalse(GrouperClientWs.mostRecentRequest,
34414 GrouperClientWs.mostRecentRequest.contains(">123<"));
34415 assertTrue(GrouperClientWs.mostRecentRequest,
34416 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34417 assertFalse(GrouperClientWs.mostRecentRequest,
34418 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34419 assertTrue(GrouperClientWs.mostRecentRequest,
34420 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34421 assertTrue(GrouperClientWs.mostRecentRequest,
34422 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34423 assertTrue(GrouperClientWs.mostRecentRequest,
34424 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34425 assertTrue(GrouperClientWs.mostRecentRequest,
34426 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34427 assertTrue(GrouperClientWs.mostRecentRequest,
34428 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34429 assertTrue(GrouperClientWs.mostRecentRequest,
34430 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34431
34432
34433
34434
34435
34436 baos = new ByteArrayOutputStream();
34437 System.setOut(new PrintStream(baos));
34438
34439 try {
34440 GrouperClient.main(GrouperClientUtils.splitTrim(
34441 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
34442 ,
34443 " "));
34444
34445 System.out.flush();
34446 output = new String(baos.toByteArray());
34447
34448 System.setOut(systemOut);
34449
34450 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34451
34452
34453
34454 pattern = Pattern
34455 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34456
34457 assertEquals(0, GrouperUtil.length(outputLines));
34458 fail("Shouldnt get here");
34459 } catch (Exception e) {
34460
34461 } finally {
34462 System.setOut(systemOut);
34463
34464 }
34465
34466 assertTrue(GrouperClientWs.mostRecentRequest,
34467 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34468 assertTrue(GrouperClientWs.mostRecentRequest,
34469 !GrouperClientWs.mostRecentRequest.contains("actions"));
34470 assertTrue(GrouperClientWs.mostRecentRequest,
34471 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34472 assertTrue(GrouperClientWs.mostRecentRequest,
34473 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34474 assertTrue(GrouperClientWs.mostRecentRequest,
34475 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34476 assertTrue(GrouperClientWs.mostRecentRequest,
34477 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34478 assertTrue(GrouperClientWs.mostRecentRequest,
34479 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34480 assertTrue(GrouperClientWs.mostRecentRequest,
34481 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34482 assertTrue(GrouperClientWs.mostRecentRequest,
34483 !GrouperClientWs.mostRecentRequest.contains("params"));
34484 assertTrue(GrouperClientWs.mostRecentRequest,
34485 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34486 assertTrue(GrouperClientWs.mostRecentRequest,
34487 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34488 assertFalse(GrouperClientWs.mostRecentRequest,
34489 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34490 assertTrue(GrouperClientWs.mostRecentRequest,
34491 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34492 assertTrue(GrouperClientWs.mostRecentRequest,
34493 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34494 assertTrue(GrouperClientWs.mostRecentRequest,
34495 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34496 assertTrue(GrouperClientWs.mostRecentRequest,
34497 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34498 assertTrue(GrouperClientWs.mostRecentRequest,
34499 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34500 assertTrue(GrouperClientWs.mostRecentRequest,
34501 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34502 assertTrue(GrouperClientWs.mostRecentRequest,
34503 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34504 assertTrue(GrouperClientWs.mostRecentRequest,
34505 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34506 assertFalse(GrouperClientWs.mostRecentRequest,
34507 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34508 assertFalse(GrouperClientWs.mostRecentRequest,
34509 GrouperClientWs.mostRecentRequest.contains("theValue"));
34510 assertFalse(GrouperClientWs.mostRecentRequest,
34511 GrouperClientWs.mostRecentRequest.contains(">123<"));
34512 assertFalse(GrouperClientWs.mostRecentRequest,
34513 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34514 assertFalse(GrouperClientWs.mostRecentRequest,
34515 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34516 assertTrue(GrouperClientWs.mostRecentRequest,
34517 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34518 assertTrue(GrouperClientWs.mostRecentRequest,
34519 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34520 assertTrue(GrouperClientWs.mostRecentRequest,
34521 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34522 assertTrue(GrouperClientWs.mostRecentRequest,
34523 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34524 assertTrue(GrouperClientWs.mostRecentRequest,
34525 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34526 assertTrue(GrouperClientWs.mostRecentRequest,
34527 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34528
34529
34530
34531
34532 baos = new ByteArrayOutputStream();
34533 System.setOut(new PrintStream(baos));
34534
34535 GrouperClient.main(GrouperClientUtils.splitTrim(
34536 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
34537 ,
34538 " "));
34539
34540 System.out.flush();
34541 output = new String(baos.toByteArray());
34542
34543 System.setOut(systemOut);
34544
34545 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34546
34547
34548
34549 pattern = Pattern
34550 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34551
34552 assertEquals(1, GrouperUtil.length(outputLines));
34553
34554 outputLine = outputLines[0];
34555
34556 matcher = pattern.matcher(outputLine);
34557
34558 assertTrue(outputLine, matcher.matches());
34559 assertEquals(outputLine, "0", matcher.group(1));
34560 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34561 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34562 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34563 assertEquals(outputLine, "assign", matcher.group(5));
34564 assertEquals(outputLine, "123", matcher.group(6));
34565 assertEquals(outputLine, "T", matcher.group(7));
34566 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34567
34568 assertTrue(GrouperClientWs.mostRecentRequest,
34569 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34570 assertTrue(GrouperClientWs.mostRecentRequest,
34571 !GrouperClientWs.mostRecentRequest.contains("actions"));
34572 assertTrue(GrouperClientWs.mostRecentRequest,
34573 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34574 assertTrue(GrouperClientWs.mostRecentRequest,
34575 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34576 assertTrue(GrouperClientWs.mostRecentRequest,
34577 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34578 assertTrue(GrouperClientWs.mostRecentRequest,
34579 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34580 assertTrue(GrouperClientWs.mostRecentRequest,
34581 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34582 assertTrue(GrouperClientWs.mostRecentRequest,
34583 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34584 assertTrue(GrouperClientWs.mostRecentRequest,
34585 !GrouperClientWs.mostRecentRequest.contains("params"));
34586 assertTrue(GrouperClientWs.mostRecentRequest,
34587 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34588 assertTrue(GrouperClientWs.mostRecentRequest,
34589 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34590 assertFalse(GrouperClientWs.mostRecentRequest,
34591 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34592 assertTrue(GrouperClientWs.mostRecentRequest,
34593 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34594 assertTrue(GrouperClientWs.mostRecentRequest,
34595 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34596 assertTrue(GrouperClientWs.mostRecentRequest,
34597 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34598 assertTrue(GrouperClientWs.mostRecentRequest,
34599 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34600 assertTrue(GrouperClientWs.mostRecentRequest,
34601 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34602 assertTrue(GrouperClientWs.mostRecentRequest,
34603 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34604 assertTrue(GrouperClientWs.mostRecentRequest,
34605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34606 assertTrue(GrouperClientWs.mostRecentRequest,
34607 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34608 assertFalse(GrouperClientWs.mostRecentRequest,
34609 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34610 assertFalse(GrouperClientWs.mostRecentRequest,
34611 GrouperClientWs.mostRecentRequest.contains("theValue"));
34612 assertFalse(GrouperClientWs.mostRecentRequest,
34613 GrouperClientWs.mostRecentRequest.contains(">123<"));
34614 assertFalse(GrouperClientWs.mostRecentRequest,
34615 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34616 assertFalse(GrouperClientWs.mostRecentRequest,
34617 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34618 assertTrue(GrouperClientWs.mostRecentRequest,
34619 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34620 assertTrue(GrouperClientWs.mostRecentRequest,
34621 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34622 assertTrue(GrouperClientWs.mostRecentRequest,
34623 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34624 assertTrue(GrouperClientWs.mostRecentRequest,
34625 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34626 assertTrue(GrouperClientWs.mostRecentRequest,
34627 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34628 assertTrue(GrouperClientWs.mostRecentRequest,
34629 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34630
34631
34632
34633
34634
34635 baos = new ByteArrayOutputStream();
34636 System.setOut(new PrintStream(baos));
34637
34638 GrouperClient.main(GrouperClientUtils.splitTrim(
34639 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
34640 ,
34641 " "));
34642
34643 System.out.flush();
34644 output = new String(baos.toByteArray());
34645
34646 System.setOut(systemOut);
34647
34648 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34649
34650
34651
34652 pattern = Pattern
34653 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34654
34655 assertEquals(1, GrouperUtil.length(outputLines));
34656
34657 outputLine = outputLines[0];
34658
34659 matcher = pattern.matcher(outputLine);
34660
34661 assertTrue(outputLine, matcher.matches());
34662 assertEquals(outputLine, "0", matcher.group(1));
34663 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34664 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34665 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34666 assertEquals(outputLine, "assign", matcher.group(5));
34667 assertEquals(outputLine, "123", matcher.group(6));
34668 assertEquals(outputLine, "T", matcher.group(7));
34669 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34670
34671 assertTrue(GrouperClientWs.mostRecentRequest,
34672 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34673 assertTrue(GrouperClientWs.mostRecentRequest,
34674 !GrouperClientWs.mostRecentRequest.contains("actions"));
34675 assertTrue(GrouperClientWs.mostRecentRequest,
34676 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34677 assertTrue(GrouperClientWs.mostRecentRequest,
34678 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34679 assertTrue(GrouperClientWs.mostRecentRequest,
34680 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34681 assertTrue(GrouperClientWs.mostRecentRequest,
34682 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34683 assertTrue(GrouperClientWs.mostRecentRequest,
34684 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34685 assertTrue(GrouperClientWs.mostRecentRequest,
34686 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34687 assertTrue(GrouperClientWs.mostRecentRequest,
34688 !GrouperClientWs.mostRecentRequest.contains("params"));
34689 assertTrue(GrouperClientWs.mostRecentRequest,
34690 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34691 assertTrue(GrouperClientWs.mostRecentRequest,
34692 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34693 assertFalse(GrouperClientWs.mostRecentRequest,
34694 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34695 assertFalse(GrouperClientWs.mostRecentRequest,
34696 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34697 assertTrue(GrouperClientWs.mostRecentRequest,
34698 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34699 assertTrue(GrouperClientWs.mostRecentRequest,
34700 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34701 assertTrue(GrouperClientWs.mostRecentRequest,
34702 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34703 assertTrue(GrouperClientWs.mostRecentRequest,
34704 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34705 assertTrue(GrouperClientWs.mostRecentRequest,
34706 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34707 assertTrue(GrouperClientWs.mostRecentRequest,
34708 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34709 assertTrue(GrouperClientWs.mostRecentRequest,
34710 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34711 assertFalse(GrouperClientWs.mostRecentRequest,
34712 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34713 assertFalse(GrouperClientWs.mostRecentRequest,
34714 GrouperClientWs.mostRecentRequest.contains("theValue"));
34715 assertFalse(GrouperClientWs.mostRecentRequest,
34716 GrouperClientWs.mostRecentRequest.contains(">123<"));
34717 assertFalse(GrouperClientWs.mostRecentRequest,
34718 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34719 assertFalse(GrouperClientWs.mostRecentRequest,
34720 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34721 assertTrue(GrouperClientWs.mostRecentRequest,
34722 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34723 assertTrue(GrouperClientWs.mostRecentRequest,
34724 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34725 assertTrue(GrouperClientWs.mostRecentRequest,
34726 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34727 assertTrue(GrouperClientWs.mostRecentRequest,
34728 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34729 assertTrue(GrouperClientWs.mostRecentRequest,
34730 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34731 assertTrue(GrouperClientWs.mostRecentRequest,
34732 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34733
34734
34735
34736
34737
34738
34739 baos = new ByteArrayOutputStream();
34740 System.setOut(new PrintStream(baos));
34741
34742 try {
34743 GrouperClient.main(GrouperClientUtils.splitTrim(
34744 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
34745 ,
34746 " "));
34747
34748 System.out.flush();
34749 output = new String(baos.toByteArray());
34750
34751 System.setOut(systemOut);
34752
34753 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34754
34755
34756
34757 pattern = Pattern
34758 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34759
34760 assertEquals(0, GrouperUtil.length(outputLines));
34761
34762 fail("shouldnt get here");
34763 } catch (Exception e) {
34764
34765 } finally {
34766 System.setOut(systemOut);
34767 }
34768
34769 assertTrue(GrouperClientWs.mostRecentRequest,
34770 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34771 assertTrue(GrouperClientWs.mostRecentRequest,
34772 !GrouperClientWs.mostRecentRequest.contains("actions"));
34773 assertTrue(GrouperClientWs.mostRecentRequest,
34774 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34775 assertTrue(GrouperClientWs.mostRecentRequest,
34776 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34777 assertTrue(GrouperClientWs.mostRecentRequest,
34778 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34779 assertTrue(GrouperClientWs.mostRecentRequest,
34780 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34781 assertTrue(GrouperClientWs.mostRecentRequest,
34782 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34783 assertTrue(GrouperClientWs.mostRecentRequest,
34784 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34785 assertTrue(GrouperClientWs.mostRecentRequest,
34786 !GrouperClientWs.mostRecentRequest.contains("params"));
34787 assertTrue(GrouperClientWs.mostRecentRequest,
34788 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34789 assertTrue(GrouperClientWs.mostRecentRequest,
34790 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34791 assertFalse(GrouperClientWs.mostRecentRequest,
34792 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34793 assertFalse(GrouperClientWs.mostRecentRequest,
34794 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34795 assertTrue(GrouperClientWs.mostRecentRequest,
34796 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34797 assertTrue(GrouperClientWs.mostRecentRequest,
34798 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34799 assertTrue(GrouperClientWs.mostRecentRequest,
34800 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34801 assertTrue(GrouperClientWs.mostRecentRequest,
34802 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34803 assertTrue(GrouperClientWs.mostRecentRequest,
34804 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34805 assertTrue(GrouperClientWs.mostRecentRequest,
34806 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34807 assertTrue(GrouperClientWs.mostRecentRequest,
34808 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34809 assertFalse(GrouperClientWs.mostRecentRequest,
34810 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34811 assertFalse(GrouperClientWs.mostRecentRequest,
34812 GrouperClientWs.mostRecentRequest.contains("theValue"));
34813 assertFalse(GrouperClientWs.mostRecentRequest,
34814 GrouperClientWs.mostRecentRequest.contains(">123<"));
34815 assertFalse(GrouperClientWs.mostRecentRequest,
34816 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34817 assertFalse(GrouperClientWs.mostRecentRequest,
34818 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34819 assertTrue(GrouperClientWs.mostRecentRequest,
34820 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34821 assertTrue(GrouperClientWs.mostRecentRequest,
34822 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34823 assertTrue(GrouperClientWs.mostRecentRequest,
34824 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34825 assertTrue(GrouperClientWs.mostRecentRequest,
34826 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34827 assertTrue(GrouperClientWs.mostRecentRequest,
34828 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34829 assertTrue(GrouperClientWs.mostRecentRequest,
34830 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34831
34832
34833
34834
34835
34836 baos = new ByteArrayOutputStream();
34837 System.setOut(new PrintStream(baos));
34838
34839 GrouperClient.main(GrouperClientUtils.splitTrim(
34840 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
34841 ,
34842 " "));
34843
34844 System.out.flush();
34845 output = new String(baos.toByteArray());
34846
34847 System.setOut(systemOut);
34848
34849 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34850
34851
34852
34853 pattern = Pattern
34854 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34855
34856 assertEquals(1, GrouperUtil.length(outputLines));
34857
34858 outputLine = outputLines[0];
34859
34860 matcher = pattern.matcher(outputLine);
34861
34862 assertTrue(outputLine, matcher.matches());
34863 assertEquals(outputLine, "0", matcher.group(1));
34864 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34865 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34866 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34867 assertEquals(outputLine, "assign", matcher.group(5));
34868 assertEquals(outputLine, "123", matcher.group(6));
34869 assertEquals(outputLine, "T", matcher.group(7));
34870 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34871
34872 assertTrue(GrouperClientWs.mostRecentRequest,
34873 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34874 assertTrue(GrouperClientWs.mostRecentRequest,
34875 !GrouperClientWs.mostRecentRequest.contains("actions"));
34876 assertTrue(GrouperClientWs.mostRecentRequest,
34877 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34878 assertTrue(GrouperClientWs.mostRecentRequest,
34879 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34880 assertTrue(GrouperClientWs.mostRecentRequest,
34881 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34882 assertTrue(GrouperClientWs.mostRecentRequest,
34883 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34884 assertTrue(GrouperClientWs.mostRecentRequest,
34885 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34886 assertTrue(GrouperClientWs.mostRecentRequest,
34887 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34888 assertTrue(GrouperClientWs.mostRecentRequest,
34889 !GrouperClientWs.mostRecentRequest.contains("params"));
34890 assertTrue(GrouperClientWs.mostRecentRequest,
34891 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34892 assertTrue(GrouperClientWs.mostRecentRequest,
34893 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34894 assertFalse(GrouperClientWs.mostRecentRequest,
34895 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34896 assertTrue(GrouperClientWs.mostRecentRequest,
34897 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34898 assertTrue(GrouperClientWs.mostRecentRequest,
34899 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34900 assertTrue(GrouperClientWs.mostRecentRequest,
34901 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34902 assertTrue(GrouperClientWs.mostRecentRequest,
34903 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34904 assertTrue(GrouperClientWs.mostRecentRequest,
34905 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34906 assertTrue(GrouperClientWs.mostRecentRequest,
34907 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34908 assertTrue(GrouperClientWs.mostRecentRequest,
34909 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34910 assertTrue(GrouperClientWs.mostRecentRequest,
34911 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34912 assertFalse(GrouperClientWs.mostRecentRequest,
34913 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34914 assertFalse(GrouperClientWs.mostRecentRequest,
34915 GrouperClientWs.mostRecentRequest.contains("theValue"));
34916 assertFalse(GrouperClientWs.mostRecentRequest,
34917 GrouperClientWs.mostRecentRequest.contains(">123<"));
34918 assertFalse(GrouperClientWs.mostRecentRequest,
34919 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34920 assertFalse(GrouperClientWs.mostRecentRequest,
34921 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34922 assertTrue(GrouperClientWs.mostRecentRequest,
34923 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34924 assertTrue(GrouperClientWs.mostRecentRequest,
34925 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34926 assertTrue(GrouperClientWs.mostRecentRequest,
34927 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34928 assertTrue(GrouperClientWs.mostRecentRequest,
34929 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34930 assertTrue(GrouperClientWs.mostRecentRequest,
34931 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34932 assertTrue(GrouperClientWs.mostRecentRequest,
34933 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34934
34935
34936
34937
34938
34939 baos = new ByteArrayOutputStream();
34940 System.setOut(new PrintStream(baos));
34941
34942 GrouperClient.main(GrouperClientUtils.splitTrim(
34943 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
34944 ,
34945 " "));
34946
34947 System.out.flush();
34948 output = new String(baos.toByteArray());
34949
34950 System.setOut(systemOut);
34951
34952 outputLines = GrouperClientUtils.splitTrim(output, "\n");
34953
34954
34955
34956 pattern = Pattern
34957 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34958
34959 assertEquals(1, GrouperUtil.length(outputLines));
34960
34961 outputLine = outputLines[0];
34962
34963 matcher = pattern.matcher(outputLine);
34964
34965 assertTrue(outputLine, matcher.matches());
34966 assertEquals(outputLine, "0", matcher.group(1));
34967 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34968 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34969 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34970 assertEquals(outputLine, "assign", matcher.group(5));
34971 assertEquals(outputLine, "123", matcher.group(6));
34972 assertEquals(outputLine, "T", matcher.group(7));
34973 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34974
34975 assertTrue(GrouperClientWs.mostRecentRequest,
34976 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34977 assertTrue(GrouperClientWs.mostRecentRequest,
34978 !GrouperClientWs.mostRecentRequest.contains("actions"));
34979 assertTrue(GrouperClientWs.mostRecentRequest,
34980 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34981 assertTrue(GrouperClientWs.mostRecentRequest,
34982 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34983 assertTrue(GrouperClientWs.mostRecentRequest,
34984 !GrouperClientWs.mostRecentRequest.contains("enabled"));
34985 assertTrue(GrouperClientWs.mostRecentRequest,
34986 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34987 assertTrue(GrouperClientWs.mostRecentRequest,
34988 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34989 assertTrue(GrouperClientWs.mostRecentRequest,
34990 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34991 assertTrue(GrouperClientWs.mostRecentRequest,
34992 !GrouperClientWs.mostRecentRequest.contains("params"));
34993 assertTrue(GrouperClientWs.mostRecentRequest,
34994 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34995 assertTrue(GrouperClientWs.mostRecentRequest,
34996 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34997 assertFalse(GrouperClientWs.mostRecentRequest,
34998 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34999 assertTrue(GrouperClientWs.mostRecentRequest,
35000 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35001 assertTrue(GrouperClientWs.mostRecentRequest,
35002 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35003 assertTrue(GrouperClientWs.mostRecentRequest,
35004 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35005 assertTrue(GrouperClientWs.mostRecentRequest,
35006 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35007 assertTrue(GrouperClientWs.mostRecentRequest,
35008 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35009 assertTrue(GrouperClientWs.mostRecentRequest,
35010 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35011 assertTrue(GrouperClientWs.mostRecentRequest,
35012 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35013 assertTrue(GrouperClientWs.mostRecentRequest,
35014 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35015 assertFalse(GrouperClientWs.mostRecentRequest,
35016 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35017 assertFalse(GrouperClientWs.mostRecentRequest,
35018 GrouperClientWs.mostRecentRequest.contains("theValue"));
35019 assertFalse(GrouperClientWs.mostRecentRequest,
35020 GrouperClientWs.mostRecentRequest.contains(">123<"));
35021 assertFalse(GrouperClientWs.mostRecentRequest,
35022 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35023 assertFalse(GrouperClientWs.mostRecentRequest,
35024 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35025 assertTrue(GrouperClientWs.mostRecentRequest,
35026 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35027 assertTrue(GrouperClientWs.mostRecentRequest,
35028 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35029 assertTrue(GrouperClientWs.mostRecentRequest,
35030 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
35031 assertTrue(GrouperClientWs.mostRecentRequest,
35032 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35033 assertTrue(GrouperClientWs.mostRecentRequest,
35034 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
35035 assertTrue(GrouperClientWs.mostRecentRequest,
35036 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35037
35038
35039
35040
35041
35042
35043 baos = new ByteArrayOutputStream();
35044 System.setOut(new PrintStream(baos));
35045
35046 try {
35047 GrouperClient.main(GrouperClientUtils.splitTrim(
35048 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
35049 ,
35050 " "));
35051
35052 System.out.flush();
35053 output = new String(baos.toByteArray());
35054
35055 System.setOut(systemOut);
35056
35057 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35058
35059
35060
35061 pattern = Pattern
35062 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35063
35064 assertEquals(0, GrouperUtil.length(outputLines));
35065 fail("Shouldnt get here");
35066 } catch (Exception e) {
35067
35068 } finally {
35069
35070 System.setOut(systemOut);
35071
35072 }
35073
35074 assertTrue(GrouperClientWs.mostRecentRequest,
35075 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35076 assertTrue(GrouperClientWs.mostRecentRequest,
35077 !GrouperClientWs.mostRecentRequest.contains("actions"));
35078 assertTrue(GrouperClientWs.mostRecentRequest,
35079 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35080 assertTrue(GrouperClientWs.mostRecentRequest,
35081 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35082 assertTrue(GrouperClientWs.mostRecentRequest,
35083 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35084 assertTrue(GrouperClientWs.mostRecentRequest,
35085 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35086 assertTrue(GrouperClientWs.mostRecentRequest,
35087 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35088 assertTrue(GrouperClientWs.mostRecentRequest,
35089 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35090 assertTrue(GrouperClientWs.mostRecentRequest,
35091 !GrouperClientWs.mostRecentRequest.contains("params"));
35092 assertTrue(GrouperClientWs.mostRecentRequest,
35093 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35094 assertTrue(GrouperClientWs.mostRecentRequest,
35095 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35096 assertFalse(GrouperClientWs.mostRecentRequest,
35097 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35098 assertTrue(GrouperClientWs.mostRecentRequest,
35099 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35100 assertTrue(GrouperClientWs.mostRecentRequest,
35101 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35102 assertTrue(GrouperClientWs.mostRecentRequest,
35103 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35104 assertTrue(GrouperClientWs.mostRecentRequest,
35105 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35106 assertTrue(GrouperClientWs.mostRecentRequest,
35107 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35108 assertTrue(GrouperClientWs.mostRecentRequest,
35109 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35110 assertTrue(GrouperClientWs.mostRecentRequest,
35111 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35112 assertTrue(GrouperClientWs.mostRecentRequest,
35113 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35114 assertFalse(GrouperClientWs.mostRecentRequest,
35115 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35116 assertFalse(GrouperClientWs.mostRecentRequest,
35117 GrouperClientWs.mostRecentRequest.contains("theValue"));
35118 assertFalse(GrouperClientWs.mostRecentRequest,
35119 GrouperClientWs.mostRecentRequest.contains(">123<"));
35120 assertFalse(GrouperClientWs.mostRecentRequest,
35121 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35122 assertFalse(GrouperClientWs.mostRecentRequest,
35123 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35124 assertTrue(GrouperClientWs.mostRecentRequest,
35125 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35126 assertTrue(GrouperClientWs.mostRecentRequest,
35127 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35128 assertTrue(GrouperClientWs.mostRecentRequest,
35129 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
35130 assertTrue(GrouperClientWs.mostRecentRequest,
35131 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35132 assertTrue(GrouperClientWs.mostRecentRequest,
35133 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
35134 assertTrue(GrouperClientWs.mostRecentRequest,
35135 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35136
35137
35138
35139
35140
35141 baos = new ByteArrayOutputStream();
35142 System.setOut(new PrintStream(baos));
35143
35144 GrouperClient.main(GrouperClientUtils.splitTrim(
35145 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
35146 ,
35147 " "));
35148
35149 System.out.flush();
35150 output = new String(baos.toByteArray());
35151
35152 System.setOut(systemOut);
35153
35154 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35155
35156
35157
35158 pattern = Pattern
35159 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35160
35161 assertEquals(1, GrouperUtil.length(outputLines));
35162
35163 outputLine = outputLines[0];
35164
35165 matcher = pattern.matcher(outputLine);
35166
35167 assertTrue(outputLine, matcher.matches());
35168 assertEquals(outputLine, "0", matcher.group(1));
35169 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35170 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35171 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35172 assertEquals(outputLine, "assign", matcher.group(5));
35173 assertEquals(outputLine, "123", matcher.group(6));
35174 assertEquals(outputLine, "T", matcher.group(7));
35175 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35176
35177 assertTrue(GrouperClientWs.mostRecentRequest,
35178 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35179 assertTrue(GrouperClientWs.mostRecentRequest,
35180 !GrouperClientWs.mostRecentRequest.contains("actions"));
35181 assertTrue(GrouperClientWs.mostRecentRequest,
35182 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35183 assertTrue(GrouperClientWs.mostRecentRequest,
35184 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35185 assertTrue(GrouperClientWs.mostRecentRequest,
35186 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35187 assertTrue(GrouperClientWs.mostRecentRequest,
35188 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35189 assertTrue(GrouperClientWs.mostRecentRequest,
35190 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35191 assertTrue(GrouperClientWs.mostRecentRequest,
35192 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35193 assertTrue(GrouperClientWs.mostRecentRequest,
35194 !GrouperClientWs.mostRecentRequest.contains("params"));
35195 assertTrue(GrouperClientWs.mostRecentRequest,
35196 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35197 assertTrue(GrouperClientWs.mostRecentRequest,
35198 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35199 assertFalse(GrouperClientWs.mostRecentRequest,
35200 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35201 assertFalse(GrouperClientWs.mostRecentRequest,
35202 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35203 assertTrue(GrouperClientWs.mostRecentRequest,
35204 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35205 assertTrue(GrouperClientWs.mostRecentRequest,
35206 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35207 assertTrue(GrouperClientWs.mostRecentRequest,
35208 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35209 assertTrue(GrouperClientWs.mostRecentRequest,
35210 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35211 assertTrue(GrouperClientWs.mostRecentRequest,
35212 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35213 assertTrue(GrouperClientWs.mostRecentRequest,
35214 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35215 assertTrue(GrouperClientWs.mostRecentRequest,
35216 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35217 assertFalse(GrouperClientWs.mostRecentRequest,
35218 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35219 assertFalse(GrouperClientWs.mostRecentRequest,
35220 GrouperClientWs.mostRecentRequest.contains("theValue"));
35221 assertFalse(GrouperClientWs.mostRecentRequest,
35222 GrouperClientWs.mostRecentRequest.contains(">123<"));
35223 assertFalse(GrouperClientWs.mostRecentRequest,
35224 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35225 assertFalse(GrouperClientWs.mostRecentRequest,
35226 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35227 assertTrue(GrouperClientWs.mostRecentRequest,
35228 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35229 assertTrue(GrouperClientWs.mostRecentRequest,
35230 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35231 assertTrue(GrouperClientWs.mostRecentRequest,
35232 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35233 assertTrue(GrouperClientWs.mostRecentRequest,
35234 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35235
35236
35237
35238
35239
35240
35241 baos = new ByteArrayOutputStream();
35242 System.setOut(new PrintStream(baos));
35243
35244 try {
35245 GrouperClient.main(GrouperClientUtils.splitTrim(
35246 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
35247 ,
35248 " "));
35249
35250 System.out.flush();
35251 output = new String(baos.toByteArray());
35252
35253 System.setOut(systemOut);
35254
35255 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35256
35257
35258
35259 pattern = Pattern
35260 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35261
35262 assertEquals(0, GrouperUtil.length(outputLines));
35263 fail("Shouldnt get here");
35264
35265 } catch (Exception e) {
35266
35267 } finally {
35268
35269 System.setOut(systemOut);
35270
35271 }
35272
35273 assertTrue(GrouperClientWs.mostRecentRequest,
35274 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35275 assertTrue(GrouperClientWs.mostRecentRequest,
35276 !GrouperClientWs.mostRecentRequest.contains("actions"));
35277 assertTrue(GrouperClientWs.mostRecentRequest,
35278 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35279 assertTrue(GrouperClientWs.mostRecentRequest,
35280 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35281 assertTrue(GrouperClientWs.mostRecentRequest,
35282 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35283 assertTrue(GrouperClientWs.mostRecentRequest,
35284 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35285 assertTrue(GrouperClientWs.mostRecentRequest,
35286 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35287 assertTrue(GrouperClientWs.mostRecentRequest,
35288 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35289 assertTrue(GrouperClientWs.mostRecentRequest,
35290 !GrouperClientWs.mostRecentRequest.contains("params"));
35291 assertTrue(GrouperClientWs.mostRecentRequest,
35292 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35293 assertTrue(GrouperClientWs.mostRecentRequest,
35294 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35295 assertFalse(GrouperClientWs.mostRecentRequest,
35296 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35297 assertFalse(GrouperClientWs.mostRecentRequest,
35298 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35299 assertTrue(GrouperClientWs.mostRecentRequest,
35300 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35301 assertTrue(GrouperClientWs.mostRecentRequest,
35302 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35303 assertTrue(GrouperClientWs.mostRecentRequest,
35304 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35305 assertTrue(GrouperClientWs.mostRecentRequest,
35306 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35307 assertTrue(GrouperClientWs.mostRecentRequest,
35308 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35309 assertTrue(GrouperClientWs.mostRecentRequest,
35310 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35311 assertTrue(GrouperClientWs.mostRecentRequest,
35312 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35313 assertFalse(GrouperClientWs.mostRecentRequest,
35314 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35315 assertFalse(GrouperClientWs.mostRecentRequest,
35316 GrouperClientWs.mostRecentRequest.contains("theValue"));
35317 assertFalse(GrouperClientWs.mostRecentRequest,
35318 GrouperClientWs.mostRecentRequest.contains(">123<"));
35319 assertFalse(GrouperClientWs.mostRecentRequest,
35320 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35321 assertFalse(GrouperClientWs.mostRecentRequest,
35322 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35323 assertTrue(GrouperClientWs.mostRecentRequest,
35324 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35325 assertTrue(GrouperClientWs.mostRecentRequest,
35326 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35327 assertTrue(GrouperClientWs.mostRecentRequest,
35328 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35329 assertTrue(GrouperClientWs.mostRecentRequest,
35330 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35331
35332
35333
35334
35335
35336 baos = new ByteArrayOutputStream();
35337 System.setOut(new PrintStream(baos));
35338
35339 GrouperClient.main(GrouperClientUtils.splitTrim(
35340 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
35341 ,
35342 " "));
35343
35344 System.out.flush();
35345 output = new String(baos.toByteArray());
35346
35347 System.setOut(systemOut);
35348
35349 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35350
35351
35352
35353 pattern = Pattern
35354 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35355
35356 assertEquals(1, GrouperUtil.length(outputLines));
35357
35358 outputLine = outputLines[0];
35359
35360 matcher = pattern.matcher(outputLine);
35361
35362 assertTrue(outputLine, matcher.matches());
35363 assertEquals(outputLine, "0", matcher.group(1));
35364 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35365 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35366 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35367 assertEquals(outputLine, "assign", matcher.group(5));
35368 assertEquals(outputLine, "123", matcher.group(6));
35369 assertEquals(outputLine, "T", matcher.group(7));
35370 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35371
35372 assertTrue(GrouperClientWs.mostRecentRequest,
35373 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35374 assertTrue(GrouperClientWs.mostRecentRequest,
35375 !GrouperClientWs.mostRecentRequest.contains("actions"));
35376 assertTrue(GrouperClientWs.mostRecentRequest,
35377 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35378 assertTrue(GrouperClientWs.mostRecentRequest,
35379 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35380 assertTrue(GrouperClientWs.mostRecentRequest,
35381 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35382 assertTrue(GrouperClientWs.mostRecentRequest,
35383 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35384 assertTrue(GrouperClientWs.mostRecentRequest,
35385 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35386 assertTrue(GrouperClientWs.mostRecentRequest,
35387 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35388 assertTrue(GrouperClientWs.mostRecentRequest,
35389 !GrouperClientWs.mostRecentRequest.contains("params"));
35390 assertTrue(GrouperClientWs.mostRecentRequest,
35391 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35392 assertTrue(GrouperClientWs.mostRecentRequest,
35393 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35394 assertFalse(GrouperClientWs.mostRecentRequest,
35395 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35396 assertTrue(GrouperClientWs.mostRecentRequest,
35397 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35398 assertTrue(GrouperClientWs.mostRecentRequest,
35399 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35400 assertTrue(GrouperClientWs.mostRecentRequest,
35401 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35402 assertTrue(GrouperClientWs.mostRecentRequest,
35403 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35404 assertTrue(GrouperClientWs.mostRecentRequest,
35405 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35406 assertTrue(GrouperClientWs.mostRecentRequest,
35407 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35408 assertTrue(GrouperClientWs.mostRecentRequest,
35409 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35410 assertTrue(GrouperClientWs.mostRecentRequest,
35411 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35412 assertFalse(GrouperClientWs.mostRecentRequest,
35413 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35414 assertFalse(GrouperClientWs.mostRecentRequest,
35415 GrouperClientWs.mostRecentRequest.contains("theValue"));
35416 assertFalse(GrouperClientWs.mostRecentRequest,
35417 GrouperClientWs.mostRecentRequest.contains(">123<"));
35418 assertFalse(GrouperClientWs.mostRecentRequest,
35419 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35420 assertFalse(GrouperClientWs.mostRecentRequest,
35421 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35422 assertTrue(GrouperClientWs.mostRecentRequest,
35423 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35424 assertTrue(GrouperClientWs.mostRecentRequest,
35425 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35426 assertTrue(GrouperClientWs.mostRecentRequest,
35427 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35428 assertTrue(GrouperClientWs.mostRecentRequest,
35429 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35430
35431
35432
35433
35434
35435
35436 baos = new ByteArrayOutputStream();
35437 System.setOut(new PrintStream(baos));
35438
35439 try {
35440 GrouperClient.main(GrouperClientUtils.splitTrim(
35441 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
35442 ,
35443 " "));
35444
35445 System.out.flush();
35446 output = new String(baos.toByteArray());
35447
35448 System.setOut(systemOut);
35449
35450 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35451
35452
35453
35454 pattern = Pattern
35455 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35456
35457 assertEquals(1, GrouperUtil.length(outputLines));
35458 fail("Shouldnt get here");
35459 } catch (Exception e) {
35460
35461 } finally {
35462
35463 System.setOut(systemOut);
35464
35465 }
35466
35467 assertTrue(GrouperClientWs.mostRecentRequest,
35468 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35469 assertTrue(GrouperClientWs.mostRecentRequest,
35470 !GrouperClientWs.mostRecentRequest.contains("actions"));
35471 assertTrue(GrouperClientWs.mostRecentRequest,
35472 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35473 assertTrue(GrouperClientWs.mostRecentRequest,
35474 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35475 assertTrue(GrouperClientWs.mostRecentRequest,
35476 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35477 assertTrue(GrouperClientWs.mostRecentRequest,
35478 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35479 assertTrue(GrouperClientWs.mostRecentRequest,
35480 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35481 assertTrue(GrouperClientWs.mostRecentRequest,
35482 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35483 assertTrue(GrouperClientWs.mostRecentRequest,
35484 !GrouperClientWs.mostRecentRequest.contains("params"));
35485 assertTrue(GrouperClientWs.mostRecentRequest,
35486 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35487 assertTrue(GrouperClientWs.mostRecentRequest,
35488 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35489 assertFalse(GrouperClientWs.mostRecentRequest,
35490 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35491 assertTrue(GrouperClientWs.mostRecentRequest,
35492 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35493 assertTrue(GrouperClientWs.mostRecentRequest,
35494 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35495 assertTrue(GrouperClientWs.mostRecentRequest,
35496 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35497 assertTrue(GrouperClientWs.mostRecentRequest,
35498 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35499 assertTrue(GrouperClientWs.mostRecentRequest,
35500 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35501 assertTrue(GrouperClientWs.mostRecentRequest,
35502 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35503 assertTrue(GrouperClientWs.mostRecentRequest,
35504 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35505 assertTrue(GrouperClientWs.mostRecentRequest,
35506 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35507 assertFalse(GrouperClientWs.mostRecentRequest,
35508 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35509 assertFalse(GrouperClientWs.mostRecentRequest,
35510 GrouperClientWs.mostRecentRequest.contains("theValue"));
35511 assertFalse(GrouperClientWs.mostRecentRequest,
35512 GrouperClientWs.mostRecentRequest.contains(">123<"));
35513 assertFalse(GrouperClientWs.mostRecentRequest,
35514 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35515 assertFalse(GrouperClientWs.mostRecentRequest,
35516 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35517 assertTrue(GrouperClientWs.mostRecentRequest,
35518 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35519 assertTrue(GrouperClientWs.mostRecentRequest,
35520 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35521 assertTrue(GrouperClientWs.mostRecentRequest,
35522 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35523 assertTrue(GrouperClientWs.mostRecentRequest,
35524 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35525
35526
35527
35528
35529
35530 baos = new ByteArrayOutputStream();
35531 System.setOut(new PrintStream(baos));
35532
35533 GrouperClient.main(GrouperClientUtils.splitTrim(
35534 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
35535 + " --assignAssignOwnerActions=assign",
35536 " "));
35537
35538 System.out.flush();
35539 output = new String(baos.toByteArray());
35540
35541 System.setOut(systemOut);
35542
35543 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35544
35545
35546
35547 pattern = Pattern
35548 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35549
35550 assertEquals(1, GrouperUtil.length(outputLines));
35551
35552 outputLine = outputLines[0];
35553
35554 matcher = pattern.matcher(outputLine);
35555
35556 assertTrue(outputLine, matcher.matches());
35557 assertEquals(outputLine, "0", matcher.group(1));
35558 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35559 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35560 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35561 assertEquals(outputLine, "assign", matcher.group(5));
35562 assertEquals(outputLine, "123", matcher.group(6));
35563 assertEquals(outputLine, "T", matcher.group(7));
35564 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35565
35566 assertTrue(GrouperClientWs.mostRecentRequest,
35567 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35568 assertTrue(GrouperClientWs.mostRecentRequest,
35569 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
35570 assertTrue(GrouperClientWs.mostRecentRequest,
35571 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35572 assertTrue(GrouperClientWs.mostRecentRequest,
35573 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35574 assertTrue(GrouperClientWs.mostRecentRequest,
35575 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35576 assertTrue(GrouperClientWs.mostRecentRequest,
35577 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35578 assertTrue(GrouperClientWs.mostRecentRequest,
35579 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35580 assertTrue(GrouperClientWs.mostRecentRequest,
35581 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35582 assertTrue(GrouperClientWs.mostRecentRequest,
35583 !GrouperClientWs.mostRecentRequest.contains("params"));
35584 assertTrue(GrouperClientWs.mostRecentRequest,
35585 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35586 assertTrue(GrouperClientWs.mostRecentRequest,
35587 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35588 assertFalse(GrouperClientWs.mostRecentRequest,
35589 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35590 assertTrue(GrouperClientWs.mostRecentRequest,
35591 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35592 assertTrue(GrouperClientWs.mostRecentRequest,
35593 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35594 assertTrue(GrouperClientWs.mostRecentRequest,
35595 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35596 assertTrue(GrouperClientWs.mostRecentRequest,
35597 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35598 assertTrue(GrouperClientWs.mostRecentRequest,
35599 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35600 assertTrue(GrouperClientWs.mostRecentRequest,
35601 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35602 assertTrue(GrouperClientWs.mostRecentRequest,
35603 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35604 assertTrue(GrouperClientWs.mostRecentRequest,
35605 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35606 assertFalse(GrouperClientWs.mostRecentRequest,
35607 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35608 assertFalse(GrouperClientWs.mostRecentRequest,
35609 GrouperClientWs.mostRecentRequest.contains("theValue"));
35610 assertFalse(GrouperClientWs.mostRecentRequest,
35611 GrouperClientWs.mostRecentRequest.contains(">123<"));
35612 assertFalse(GrouperClientWs.mostRecentRequest,
35613 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35614 assertFalse(GrouperClientWs.mostRecentRequest,
35615 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35616 assertTrue(GrouperClientWs.mostRecentRequest,
35617 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35618 assertTrue(GrouperClientWs.mostRecentRequest,
35619 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35620 assertTrue(GrouperClientWs.mostRecentRequest,
35621 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35622 assertTrue(GrouperClientWs.mostRecentRequest,
35623 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
35624
35625
35626
35627
35628
35629 baos = new ByteArrayOutputStream();
35630 System.setOut(new PrintStream(baos));
35631
35632 GrouperClient.main(GrouperClientUtils.splitTrim(
35633 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
35634 + " --assignAssignOwnerActions=assign2",
35635 " "));
35636
35637 System.out.flush();
35638 output = new String(baos.toByteArray());
35639
35640 System.setOut(systemOut);
35641
35642 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35643
35644
35645
35646 pattern = Pattern
35647 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35648
35649 assertEquals(0, GrouperUtil.length(outputLines));
35650
35651 assertTrue(GrouperClientWs.mostRecentRequest,
35652 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35653 assertTrue(GrouperClientWs.mostRecentRequest,
35654 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
35655 assertTrue(GrouperClientWs.mostRecentRequest,
35656 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35657 assertTrue(GrouperClientWs.mostRecentRequest,
35658 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35659 assertTrue(GrouperClientWs.mostRecentRequest,
35660 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35661 assertTrue(GrouperClientWs.mostRecentRequest,
35662 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35663 assertTrue(GrouperClientWs.mostRecentRequest,
35664 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35665 assertTrue(GrouperClientWs.mostRecentRequest,
35666 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35667 assertTrue(GrouperClientWs.mostRecentRequest,
35668 !GrouperClientWs.mostRecentRequest.contains("params"));
35669 assertTrue(GrouperClientWs.mostRecentRequest,
35670 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35671 assertTrue(GrouperClientWs.mostRecentRequest,
35672 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35673 assertFalse(GrouperClientWs.mostRecentRequest,
35674 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35675 assertTrue(GrouperClientWs.mostRecentRequest,
35676 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35677 assertTrue(GrouperClientWs.mostRecentRequest,
35678 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35679 assertTrue(GrouperClientWs.mostRecentRequest,
35680 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35681 assertTrue(GrouperClientWs.mostRecentRequest,
35682 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35683 assertTrue(GrouperClientWs.mostRecentRequest,
35684 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35685 assertTrue(GrouperClientWs.mostRecentRequest,
35686 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35687 assertTrue(GrouperClientWs.mostRecentRequest,
35688 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35689 assertTrue(GrouperClientWs.mostRecentRequest,
35690 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35691 assertFalse(GrouperClientWs.mostRecentRequest,
35692 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35693 assertFalse(GrouperClientWs.mostRecentRequest,
35694 GrouperClientWs.mostRecentRequest.contains("theValue"));
35695 assertFalse(GrouperClientWs.mostRecentRequest,
35696 GrouperClientWs.mostRecentRequest.contains(">123<"));
35697 assertFalse(GrouperClientWs.mostRecentRequest,
35698 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35699 assertFalse(GrouperClientWs.mostRecentRequest,
35700 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35701 assertTrue(GrouperClientWs.mostRecentRequest,
35702 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35703 assertTrue(GrouperClientWs.mostRecentRequest,
35704 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35705 assertTrue(GrouperClientWs.mostRecentRequest,
35706 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35707 assertTrue(GrouperClientWs.mostRecentRequest,
35708 GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
35709
35710
35711
35712
35713
35714
35715 baos = new ByteArrayOutputStream();
35716 System.setOut(new PrintStream(baos));
35717
35718 GrouperClient.main(GrouperClientUtils.splitTrim(
35719 "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --ownerMembershipAny0SubjectId=" + member.getSubjectId()
35720 + " --ownerMembershipAny0GroupName=" + group1.getName()
35721 ,
35722 " "));
35723
35724 System.out.flush();
35725 output = new String(baos.toByteArray());
35726
35727 System.setOut(systemOut);
35728
35729 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35730
35731
35732
35733 pattern = Pattern
35734 .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35735
35736 assertEquals(1, GrouperUtil.length(outputLines));
35737
35738 outputLine = outputLines[0];
35739
35740 matcher = pattern.matcher(outputLine);
35741
35742 assertTrue(outputLine, matcher.matches());
35743 assertEquals(outputLine, "0", matcher.group(1));
35744 assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35745 assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35746 assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35747 assertEquals(outputLine, "assign", matcher.group(5));
35748 assertEquals(outputLine, "123", matcher.group(6));
35749 assertEquals(outputLine, "T", matcher.group(7));
35750 assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35751
35752 assertTrue(GrouperClientWs.mostRecentRequest,
35753 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35754 assertTrue(GrouperClientWs.mostRecentRequest,
35755 !GrouperClientWs.mostRecentRequest.contains("<actions>"));
35756 assertTrue(GrouperClientWs.mostRecentRequest,
35757 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35758 assertTrue(GrouperClientWs.mostRecentRequest,
35759 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35760 assertTrue(GrouperClientWs.mostRecentRequest,
35761 !GrouperClientWs.mostRecentRequest.contains("enabled"));
35762 assertTrue(GrouperClientWs.mostRecentRequest,
35763 !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35764 assertTrue(GrouperClientWs.mostRecentRequest,
35765 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35766 assertTrue(GrouperClientWs.mostRecentRequest,
35767 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35768 assertTrue(GrouperClientWs.mostRecentRequest,
35769 !GrouperClientWs.mostRecentRequest.contains("params"));
35770 assertTrue(GrouperClientWs.mostRecentRequest,
35771 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35772 assertTrue(GrouperClientWs.mostRecentRequest,
35773 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35774 assertFalse(GrouperClientWs.mostRecentRequest,
35775 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35776 assertFalse(GrouperClientWs.mostRecentRequest,
35777 GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35778 assertTrue(GrouperClientWs.mostRecentRequest,
35779 !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35780 assertTrue(GrouperClientWs.mostRecentRequest,
35781 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35782 assertTrue(GrouperClientWs.mostRecentRequest,
35783 !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35784 assertTrue(GrouperClientWs.mostRecentRequest,
35785 GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35786 assertTrue(GrouperClientWs.mostRecentRequest,
35787 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35788 assertTrue(GrouperClientWs.mostRecentRequest,
35789 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35790 assertTrue(GrouperClientWs.mostRecentRequest,
35791 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35792 assertFalse(GrouperClientWs.mostRecentRequest,
35793 GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35794 assertFalse(GrouperClientWs.mostRecentRequest,
35795 GrouperClientWs.mostRecentRequest.contains("theValue"));
35796 assertFalse(GrouperClientWs.mostRecentRequest,
35797 GrouperClientWs.mostRecentRequest.contains(">123<"));
35798 assertFalse(GrouperClientWs.mostRecentRequest,
35799 GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35800 assertFalse(GrouperClientWs.mostRecentRequest,
35801 GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35802 assertTrue(GrouperClientWs.mostRecentRequest,
35803 !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35804 assertTrue(GrouperClientWs.mostRecentRequest,
35805 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35806 assertTrue(GrouperClientWs.mostRecentRequest,
35807 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35808 assertTrue(GrouperClientWs.mostRecentRequest,
35809 !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
35810
35811
35812 } finally {
35813 System.setOut(systemOut);
35814 }
35815
35816 }
35817
35818
35819
35820
35821 public void testAssignAttributesBatchGroup() throws Exception {
35822
35823 AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
35824
35825 final AttributeDef attributeDef = attributeDefName.getAttributeDef();
35826
35827 attributeDef.setValueType(AttributeDefValueType.integer);
35828 attributeDef.setMultiValued(true);
35829 attributeDef.store();
35830
35831 Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
35832 .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
35833 .assignDescription("description").save();
35834
35835
35836 group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
35837 attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
35838
35839 AttributeAssign attributeAssign = null;
35840
35841
35842
35843 PrintStream systemOut = System.out;
35844
35845 ByteArrayOutputStream baos = new ByteArrayOutputStream();
35846 System.setOut(new PrintStream(baos));
35847
35848 try {
35849
35850 GrouperClient.main(GrouperClientUtils.splitTrim(
35851 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
35852 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign",
35853 " "));
35854
35855 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
35856
35857 System.out.flush();
35858 String output = new String(baos.toByteArray());
35859
35860 System.setOut(systemOut);
35861
35862 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
35863
35864
35865
35866 Pattern pattern = Pattern
35867 .compile("^Index\\: (\\d+), itemIndex: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), " +
35868 "values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
35869 String outputLine = outputLines[0];
35870
35871 Matcher matcher = pattern.matcher(outputLines[0]);
35872
35873 assertTrue(outputLine, matcher.matches());
35874 assertEquals(outputLine, "0", matcher.group(1));
35875 assertEquals(outputLine, "0", matcher.group(2));
35876 assertEquals(outputLine, "group", matcher.group(3));
35877 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
35878 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
35879 assertEquals(outputLine, "assign", matcher.group(6));
35880 assertEquals(outputLine, "none", matcher.group(7));
35881 assertEquals(outputLine, "T", matcher.group(8));
35882 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
35883 assertEquals(outputLine, "T", matcher.group(10));
35884 assertEquals(outputLine, "F", matcher.group(11));
35885 assertEquals(outputLine, "F", matcher.group(12));
35886
35887 assertTrue(GrouperClientWs.mostRecentRequest,
35888 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35889 assertTrue(GrouperClientWs.mostRecentRequest,
35890 !GrouperClientWs.mostRecentRequest.contains("action"));
35891 assertTrue(GrouperClientWs.mostRecentRequest,
35892 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
35893 assertTrue(GrouperClientWs.mostRecentRequest,
35894 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
35895 assertTrue(GrouperClientWs.mostRecentRequest,
35896 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
35897 assertTrue(GrouperClientWs.mostRecentRequest,
35898 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
35899 assertTrue(GrouperClientWs.mostRecentRequest,
35900 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
35901 assertTrue(GrouperClientWs.mostRecentRequest,
35902 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35903 assertTrue(GrouperClientWs.mostRecentRequest,
35904 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35905 assertTrue(GrouperClientWs.mostRecentRequest,
35906 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
35907 assertTrue(GrouperClientWs.mostRecentRequest,
35908 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35909 assertTrue(GrouperClientWs.mostRecentRequest,
35910 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35911 assertTrue(GrouperClientWs.mostRecentRequest,
35912 !GrouperClientWs.mostRecentRequest.contains("params"));
35913 assertTrue(GrouperClientWs.mostRecentRequest,
35914 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35915 assertTrue(GrouperClientWs.mostRecentRequest,
35916 !GrouperClientWs.mostRecentRequest.contains("values"));
35917 assertTrue(GrouperClientWs.mostRecentRequest,
35918 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
35919 assertTrue(GrouperClientWs.mostRecentRequest,
35920 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
35921 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
35922 assertTrue(GrouperClientWs.mostRecentRequest,
35923 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
35924 assertTrue(GrouperClientWs.mostRecentRequest,
35925 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
35926 assertTrue(GrouperClientWs.mostRecentRequest,
35927 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
35928 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
35929 assertTrue(GrouperClientWs.mostRecentRequest,
35930 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
35931 assertTrue(GrouperClientWs.mostRecentRequest,
35932 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
35933 assertTrue(GrouperClientWs.mostRecentRequest,
35934 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
35935 assertTrue(GrouperClientWs.mostRecentRequest,
35936 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
35937
35938
35939
35940
35941
35942 baos = new ByteArrayOutputStream();
35943 System.setOut(new PrintStream(baos));
35944
35945 GrouperClient.main(GrouperClientUtils.splitTrim(
35946 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
35947 "--entry_0_uuidOfAttributeDefName=" + attributeDefName.getId() + " --entry_0_ownerGroupName=test:groupTestAttrAssign",
35948 " "));
35949
35950 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
35951
35952 System.out.flush();
35953 output = new String(baos.toByteArray());
35954
35955 System.setOut(systemOut);
35956
35957 outputLines = GrouperClientUtils.splitTrim(output, "\n");
35958
35959 outputLine = outputLines[0];
35960
35961 matcher = pattern.matcher(outputLines[0]);
35962
35963 assertTrue(outputLine, matcher.matches());
35964 assertEquals(outputLine, "0", matcher.group(1));
35965 assertEquals(outputLine, "0", matcher.group(2));
35966 assertEquals(outputLine, "group", matcher.group(3));
35967 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
35968 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
35969 assertEquals(outputLine, "assign", matcher.group(6));
35970 assertEquals(outputLine, "none", matcher.group(7));
35971 assertEquals(outputLine, "T", matcher.group(8));
35972 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
35973 assertEquals(outputLine, "F", matcher.group(10));
35974 assertEquals(outputLine, "F", matcher.group(11));
35975
35976 assertTrue(GrouperClientWs.mostRecentRequest,
35977 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35978 assertTrue(GrouperClientWs.mostRecentRequest,
35979 !GrouperClientWs.mostRecentRequest.contains("action"));
35980 assertTrue(GrouperClientWs.mostRecentRequest,
35981 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
35982 assertTrue(GrouperClientWs.mostRecentRequest,
35983 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
35984 assertTrue(GrouperClientWs.mostRecentRequest,
35985 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
35986 assertTrue(GrouperClientWs.mostRecentRequest,
35987 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
35988 assertTrue(GrouperClientWs.mostRecentRequest,
35989 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
35990 assertTrue(GrouperClientWs.mostRecentRequest,
35991 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35992 assertTrue(GrouperClientWs.mostRecentRequest,
35993 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35994 assertTrue(GrouperClientWs.mostRecentRequest,
35995 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
35996 assertTrue(GrouperClientWs.mostRecentRequest,
35997 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35998 assertTrue(GrouperClientWs.mostRecentRequest,
35999 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36000 assertTrue(GrouperClientWs.mostRecentRequest,
36001 !GrouperClientWs.mostRecentRequest.contains("params"));
36002 assertTrue(GrouperClientWs.mostRecentRequest,
36003 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36004 assertTrue(GrouperClientWs.mostRecentRequest,
36005 !GrouperClientWs.mostRecentRequest.contains("values"));
36006 assertTrue(GrouperClientWs.mostRecentRequest,
36007 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36008 assertTrue(GrouperClientWs.mostRecentRequest,
36009 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36010 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
36011 assertTrue(GrouperClientWs.mostRecentRequest,
36012 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36013 assertTrue(GrouperClientWs.mostRecentRequest,
36014 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36015 assertTrue(GrouperClientWs.mostRecentRequest,
36016 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36017 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36018 assertTrue(GrouperClientWs.mostRecentRequest,
36019 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36020 assertTrue(GrouperClientWs.mostRecentRequest,
36021 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36022 assertTrue(GrouperClientWs.mostRecentRequest,
36023 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36024 assertTrue(GrouperClientWs.mostRecentRequest,
36025 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36026
36027
36028
36029
36030 baos = new ByteArrayOutputStream();
36031 System.setOut(new PrintStream(baos));
36032
36033 GrouperClient.main(GrouperClientUtils.splitTrim(
36034 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36035 "--entry_0_idIndexOfAttributeDefName=" + attributeDefName.getIdIndex() + " --entry_0_ownerGroupName=test:groupTestAttrAssign",
36036 " "));
36037
36038 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36039
36040 System.out.flush();
36041 output = new String(baos.toByteArray());
36042
36043 System.setOut(systemOut);
36044
36045 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36046
36047 outputLine = outputLines[0];
36048
36049 matcher = pattern.matcher(outputLines[0]);
36050
36051 assertTrue(outputLine, matcher.matches());
36052 assertEquals(outputLine, "0", matcher.group(1));
36053 assertEquals(outputLine, "0", matcher.group(2));
36054 assertEquals(outputLine, "group", matcher.group(3));
36055 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36056 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36057 assertEquals(outputLine, "assign", matcher.group(6));
36058 assertEquals(outputLine, "none", matcher.group(7));
36059 assertEquals(outputLine, "T", matcher.group(8));
36060 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36061 assertEquals(outputLine, "F", matcher.group(10));
36062 assertEquals(outputLine, "F", matcher.group(11));
36063
36064 assertTrue(GrouperClientWs.mostRecentRequest,
36065 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36066 assertTrue(GrouperClientWs.mostRecentRequest,
36067 !GrouperClientWs.mostRecentRequest.contains("action"));
36068 assertTrue(GrouperClientWs.mostRecentRequest,
36069 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36070 assertTrue(GrouperClientWs.mostRecentRequest,
36071 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36072 assertTrue(GrouperClientWs.mostRecentRequest,
36073 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36074 assertTrue(GrouperClientWs.mostRecentRequest,
36075 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36076 assertTrue(GrouperClientWs.mostRecentRequest,
36077 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36078 assertTrue(GrouperClientWs.mostRecentRequest,
36079 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36080 assertTrue(GrouperClientWs.mostRecentRequest,
36081 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36082 assertTrue(GrouperClientWs.mostRecentRequest,
36083 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36084 assertTrue(GrouperClientWs.mostRecentRequest,
36085 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36086 assertTrue(GrouperClientWs.mostRecentRequest,
36087 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36088 assertTrue(GrouperClientWs.mostRecentRequest,
36089 !GrouperClientWs.mostRecentRequest.contains("params"));
36090 assertTrue(GrouperClientWs.mostRecentRequest,
36091 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36092 assertTrue(GrouperClientWs.mostRecentRequest,
36093 !GrouperClientWs.mostRecentRequest.contains("values"));
36094 assertTrue(GrouperClientWs.mostRecentRequest,
36095 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36096 assertTrue(GrouperClientWs.mostRecentRequest,
36097 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36098 && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getIdIndex().toString()));
36099 assertTrue(GrouperClientWs.mostRecentRequest,
36100 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36101 assertTrue(GrouperClientWs.mostRecentRequest,
36102 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36103 assertTrue(GrouperClientWs.mostRecentRequest,
36104 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36105 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36106 assertTrue(GrouperClientWs.mostRecentRequest,
36107 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36108 assertTrue(GrouperClientWs.mostRecentRequest,
36109 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36110 assertTrue(GrouperClientWs.mostRecentRequest,
36111 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36112 assertTrue(GrouperClientWs.mostRecentRequest,
36113 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36114
36115
36116
36117
36118 baos = new ByteArrayOutputStream();
36119 System.setOut(new PrintStream(baos));
36120
36121 GrouperClient.main(GrouperClientUtils.splitTrim(
36122 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36123 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupUuid=" + group.getUuid(),
36124 " "));
36125
36126 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36127
36128 System.out.flush();
36129 output = new String(baos.toByteArray());
36130
36131 System.setOut(systemOut);
36132
36133 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36134
36135 outputLine = outputLines[0];
36136
36137 matcher = pattern.matcher(outputLines[0]);
36138
36139 assertTrue(outputLine, matcher.matches());
36140 assertEquals(outputLine, "0", matcher.group(1));
36141 assertEquals(outputLine, "0", matcher.group(2));
36142 assertEquals(outputLine, "group", matcher.group(3));
36143 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36144 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36145 assertEquals(outputLine, "assign", matcher.group(6));
36146 assertEquals(outputLine, "none", matcher.group(7));
36147 assertEquals(outputLine, "T", matcher.group(8));
36148 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36149 assertEquals(outputLine, "F", matcher.group(10));
36150 assertEquals(outputLine, "F", matcher.group(11));
36151 assertEquals(outputLine, "F", matcher.group(12));
36152
36153 assertTrue(GrouperClientWs.mostRecentRequest,
36154 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36155 assertTrue(GrouperClientWs.mostRecentRequest,
36156 !GrouperClientWs.mostRecentRequest.contains("action"));
36157 assertTrue(GrouperClientWs.mostRecentRequest,
36158 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36159 assertTrue(GrouperClientWs.mostRecentRequest,
36160 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36161 assertTrue(GrouperClientWs.mostRecentRequest,
36162 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36163 assertTrue(GrouperClientWs.mostRecentRequest,
36164 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36165 assertTrue(GrouperClientWs.mostRecentRequest,
36166 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36167 assertTrue(GrouperClientWs.mostRecentRequest,
36168 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36169 assertTrue(GrouperClientWs.mostRecentRequest,
36170 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36171 assertTrue(GrouperClientWs.mostRecentRequest,
36172 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36173 assertTrue(GrouperClientWs.mostRecentRequest,
36174 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36175 assertTrue(GrouperClientWs.mostRecentRequest,
36176 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36177 assertTrue(GrouperClientWs.mostRecentRequest,
36178 !GrouperClientWs.mostRecentRequest.contains("params"));
36179 assertTrue(GrouperClientWs.mostRecentRequest,
36180 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36181 assertTrue(GrouperClientWs.mostRecentRequest,
36182 !GrouperClientWs.mostRecentRequest.contains("values"));
36183 assertTrue(GrouperClientWs.mostRecentRequest,
36184 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36185 assertTrue(GrouperClientWs.mostRecentRequest,
36186 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36187 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36188 assertTrue(GrouperClientWs.mostRecentRequest,
36189 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36190 assertTrue(GrouperClientWs.mostRecentRequest,
36191 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36192 assertTrue(GrouperClientWs.mostRecentRequest,
36193 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36194 && GrouperClientWs.mostRecentRequest.contains(group.getUuid()));
36195 assertTrue(GrouperClientWs.mostRecentRequest,
36196 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36197 assertTrue(GrouperClientWs.mostRecentRequest,
36198 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36199 assertTrue(GrouperClientWs.mostRecentRequest,
36200 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36201 assertTrue(GrouperClientWs.mostRecentRequest,
36202 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36203
36204
36205
36206
36207 baos = new ByteArrayOutputStream();
36208 System.setOut(new PrintStream(baos));
36209
36210 GrouperClient.main(GrouperClientUtils.splitTrim(
36211 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36212 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupIdIndex=" + group.getIdIndex(),
36213 " "));
36214
36215 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36216
36217 System.out.flush();
36218 output = new String(baos.toByteArray());
36219
36220 System.setOut(systemOut);
36221
36222 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36223
36224 outputLine = outputLines[0];
36225
36226 matcher = pattern.matcher(outputLines[0]);
36227
36228 assertTrue(outputLine, matcher.matches());
36229 assertEquals(outputLine, "0", matcher.group(1));
36230 assertEquals(outputLine, "0", matcher.group(2));
36231 assertEquals(outputLine, "group", matcher.group(3));
36232 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36233 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36234 assertEquals(outputLine, "assign", matcher.group(6));
36235 assertEquals(outputLine, "none", matcher.group(7));
36236 assertEquals(outputLine, "T", matcher.group(8));
36237 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36238 assertEquals(outputLine, "F", matcher.group(10));
36239 assertEquals(outputLine, "F", matcher.group(11));
36240 assertEquals(outputLine, "F", matcher.group(12));
36241
36242 assertTrue(GrouperClientWs.mostRecentRequest,
36243 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36244 assertTrue(GrouperClientWs.mostRecentRequest,
36245 !GrouperClientWs.mostRecentRequest.contains("action"));
36246 assertTrue(GrouperClientWs.mostRecentRequest,
36247 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36248 assertTrue(GrouperClientWs.mostRecentRequest,
36249 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36250 assertTrue(GrouperClientWs.mostRecentRequest,
36251 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36252 assertTrue(GrouperClientWs.mostRecentRequest,
36253 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36254 assertTrue(GrouperClientWs.mostRecentRequest,
36255 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36256 assertTrue(GrouperClientWs.mostRecentRequest,
36257 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36258 assertTrue(GrouperClientWs.mostRecentRequest,
36259 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36260 assertTrue(GrouperClientWs.mostRecentRequest,
36261 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36262 assertTrue(GrouperClientWs.mostRecentRequest,
36263 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36264 assertTrue(GrouperClientWs.mostRecentRequest,
36265 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36266 assertTrue(GrouperClientWs.mostRecentRequest,
36267 !GrouperClientWs.mostRecentRequest.contains("params"));
36268 assertTrue(GrouperClientWs.mostRecentRequest,
36269 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36270 assertTrue(GrouperClientWs.mostRecentRequest,
36271 !GrouperClientWs.mostRecentRequest.contains("values"));
36272 assertTrue(GrouperClientWs.mostRecentRequest,
36273 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36274 assertTrue(GrouperClientWs.mostRecentRequest,
36275 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36276 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36277 assertTrue(GrouperClientWs.mostRecentRequest,
36278 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36279 assertTrue(GrouperClientWs.mostRecentRequest,
36280 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36281 assertTrue(GrouperClientWs.mostRecentRequest,
36282 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36283 && GrouperClientWs.mostRecentRequest.contains(group.getIdIndex().toString()));
36284 assertTrue(GrouperClientWs.mostRecentRequest,
36285 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36286 assertTrue(GrouperClientWs.mostRecentRequest,
36287 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36288 assertTrue(GrouperClientWs.mostRecentRequest,
36289 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36290 assertTrue(GrouperClientWs.mostRecentRequest,
36291 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36292
36293
36294
36295
36296 baos = new ByteArrayOutputStream();
36297 System.setOut(new PrintStream(baos));
36298
36299 GrouperClient.main(GrouperClientUtils.splitTrim(
36300 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36301 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36302 + " --entry_0_assignmentEnabledTime=2010/03/05_17:05:13.123",
36303 " "));
36304
36305 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36306
36307 System.out.flush();
36308 output = new String(baos.toByteArray());
36309
36310 System.setOut(systemOut);
36311
36312 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36313
36314 outputLine = outputLines[0];
36315
36316 matcher = pattern.matcher(outputLines[0]);
36317
36318 assertTrue(outputLine, matcher.matches());
36319 assertEquals(outputLine, "0", matcher.group(1));
36320 assertEquals(outputLine, "0", matcher.group(2));
36321 assertEquals(outputLine, "group", matcher.group(3));
36322 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36323 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36324 assertEquals(outputLine, "assign", matcher.group(6));
36325 assertEquals(outputLine, "none", matcher.group(7));
36326 assertEquals(outputLine, "T", matcher.group(8));
36327 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36328 assertEquals(outputLine, "T", matcher.group(10));
36329 assertEquals(outputLine, "F", matcher.group(11));
36330
36331 assertTrue(GrouperClientWs.mostRecentRequest,
36332 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36333 assertTrue(GrouperClientWs.mostRecentRequest,
36334 !GrouperClientWs.mostRecentRequest.contains("action"));
36335 assertTrue(GrouperClientWs.mostRecentRequest,
36336 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36337 assertTrue(GrouperClientWs.mostRecentRequest,
36338 GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime")
36339 && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
36340 assertTrue(GrouperClientWs.mostRecentResponse,
36341 GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
36342 assertTrue(GrouperClientWs.mostRecentRequest,
36343 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36344 assertTrue(GrouperClientWs.mostRecentRequest,
36345 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36346 assertTrue(GrouperClientWs.mostRecentRequest,
36347 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36348 assertTrue(GrouperClientWs.mostRecentRequest,
36349 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36350 assertTrue(GrouperClientWs.mostRecentRequest,
36351 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36352 assertTrue(GrouperClientWs.mostRecentRequest,
36353 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36354 assertTrue(GrouperClientWs.mostRecentRequest,
36355 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36356 assertTrue(GrouperClientWs.mostRecentRequest,
36357 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36358 assertTrue(GrouperClientWs.mostRecentRequest,
36359 !GrouperClientWs.mostRecentRequest.contains("params"));
36360 assertTrue(GrouperClientWs.mostRecentRequest,
36361 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36362 assertTrue(GrouperClientWs.mostRecentRequest,
36363 !GrouperClientWs.mostRecentRequest.contains("values"));
36364 assertTrue(GrouperClientWs.mostRecentRequest,
36365 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36366 assertTrue(GrouperClientWs.mostRecentRequest,
36367 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36368 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36369 assertTrue(GrouperClientWs.mostRecentRequest,
36370 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36371 assertTrue(GrouperClientWs.mostRecentRequest,
36372 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36373 assertTrue(GrouperClientWs.mostRecentRequest,
36374 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36375 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36376 assertTrue(GrouperClientWs.mostRecentRequest,
36377 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36378 assertTrue(GrouperClientWs.mostRecentRequest,
36379 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36380 assertTrue(GrouperClientWs.mostRecentRequest,
36381 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36382 assertTrue(GrouperClientWs.mostRecentRequest,
36383 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36384
36385
36386
36387
36388 baos = new ByteArrayOutputStream();
36389 System.setOut(new PrintStream(baos));
36390
36391 GrouperClient.main(GrouperClientUtils.splitTrim(
36392 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36393 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36394 + " --entry_0_assignmentDisabledTime=2010/03/05_17:05:13.123",
36395 " "));
36396
36397 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36398
36399 System.out.flush();
36400 output = new String(baos.toByteArray());
36401
36402 System.setOut(systemOut);
36403
36404 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36405
36406 outputLine = outputLines[0];
36407
36408 matcher = pattern.matcher(outputLines[0]);
36409
36410 assertTrue(outputLine, matcher.matches());
36411 assertEquals(outputLine, "0", matcher.group(1));
36412 assertEquals(outputLine, "0", matcher.group(2));
36413 assertEquals(outputLine, "group", matcher.group(3));
36414 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36415 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36416 assertEquals(outputLine, "assign", matcher.group(6));
36417 assertEquals(outputLine, "none", matcher.group(7));
36418 assertEquals(outputLine, "F", matcher.group(8));
36419 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36420 assertEquals(outputLine, "T", matcher.group(10));
36421 assertEquals(outputLine, "F", matcher.group(11));
36422
36423 assertTrue(GrouperClientWs.mostRecentRequest,
36424 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36425 assertTrue(GrouperClientWs.mostRecentRequest,
36426 !GrouperClientWs.mostRecentRequest.contains("action"));
36427 assertTrue(GrouperClientWs.mostRecentRequest,
36428 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36429 assertTrue(GrouperClientWs.mostRecentRequest,
36430 GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime")
36431 && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
36432 assertTrue(GrouperClientWs.mostRecentResponse,
36433 GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
36434 assertTrue(GrouperClientWs.mostRecentRequest,
36435 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36436 assertTrue(GrouperClientWs.mostRecentRequest,
36437 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36438 assertTrue(GrouperClientWs.mostRecentRequest,
36439 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36440 assertTrue(GrouperClientWs.mostRecentRequest,
36441 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36442 assertTrue(GrouperClientWs.mostRecentRequest,
36443 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36444 assertTrue(GrouperClientWs.mostRecentRequest,
36445 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36446 assertTrue(GrouperClientWs.mostRecentRequest,
36447 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36448 assertTrue(GrouperClientWs.mostRecentRequest,
36449 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36450 assertTrue(GrouperClientWs.mostRecentRequest,
36451 !GrouperClientWs.mostRecentRequest.contains("params"));
36452 assertTrue(GrouperClientWs.mostRecentRequest,
36453 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36454 assertTrue(GrouperClientWs.mostRecentRequest,
36455 !GrouperClientWs.mostRecentRequest.contains("values"));
36456 assertTrue(GrouperClientWs.mostRecentRequest,
36457 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36458 assertTrue(GrouperClientWs.mostRecentRequest,
36459 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36460 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36461 assertTrue(GrouperClientWs.mostRecentRequest,
36462 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36463 assertTrue(GrouperClientWs.mostRecentRequest,
36464 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36465 assertTrue(GrouperClientWs.mostRecentRequest,
36466 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36467 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36468 assertTrue(GrouperClientWs.mostRecentRequest,
36469 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36470 assertTrue(GrouperClientWs.mostRecentRequest,
36471 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36472 assertTrue(GrouperClientWs.mostRecentRequest,
36473 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36474 assertTrue(GrouperClientWs.mostRecentRequest,
36475 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36476
36477
36478
36479
36480 baos = new ByteArrayOutputStream();
36481 System.setOut(new PrintStream(baos));
36482
36483 GrouperClient.main(GrouperClientUtils.splitTrim(
36484 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36485 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36486 + " --entry_0_assignmentNotes=theNotes",
36487 " "));
36488
36489 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36490
36491 System.out.flush();
36492 output = new String(baos.toByteArray());
36493
36494 System.setOut(systemOut);
36495
36496 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36497
36498 outputLine = outputLines[0];
36499
36500 matcher = pattern.matcher(outputLines[0]);
36501
36502 assertTrue(outputLine, matcher.matches());
36503 assertEquals(outputLine, "0", matcher.group(1));
36504 assertEquals(outputLine, "0", matcher.group(2));
36505 assertEquals(outputLine, "group", matcher.group(3));
36506 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36507 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36508 assertEquals(outputLine, "assign", matcher.group(6));
36509 assertEquals(outputLine, "none", matcher.group(7));
36510 assertEquals(outputLine, "T", matcher.group(8));
36511 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36512 assertEquals(outputLine, "T", matcher.group(10));
36513 assertEquals(outputLine, "F", matcher.group(11));
36514
36515 assertTrue(GrouperClientWs.mostRecentRequest,
36516 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36517 assertTrue(GrouperClientWs.mostRecentRequest,
36518 !GrouperClientWs.mostRecentRequest.contains("action"));
36519 assertTrue(GrouperClientWs.mostRecentRequest,
36520 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36521 assertTrue(GrouperClientWs.mostRecentRequest,
36522 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36523 assertTrue(GrouperClientWs.mostRecentResponse,
36524 GrouperClientWs.mostRecentResponse.contains("theNotes"));
36525 assertTrue(GrouperClientWs.mostRecentRequest,
36526 GrouperClientWs.mostRecentRequest.contains("assignmentNotes")
36527 && GrouperClientWs.mostRecentRequest.contains("theNotes") );
36528 assertTrue(GrouperClientWs.mostRecentRequest,
36529 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36530 assertTrue(GrouperClientWs.mostRecentRequest,
36531 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36532 assertTrue(GrouperClientWs.mostRecentRequest,
36533 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36534 assertTrue(GrouperClientWs.mostRecentRequest,
36535 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36536 assertTrue(GrouperClientWs.mostRecentRequest,
36537 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36538 assertTrue(GrouperClientWs.mostRecentRequest,
36539 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36540 assertTrue(GrouperClientWs.mostRecentRequest,
36541 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36542 assertTrue(GrouperClientWs.mostRecentRequest,
36543 !GrouperClientWs.mostRecentRequest.contains("params"));
36544 assertTrue(GrouperClientWs.mostRecentRequest,
36545 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36546 assertTrue(GrouperClientWs.mostRecentRequest,
36547 !GrouperClientWs.mostRecentRequest.contains("values"));
36548 assertTrue(GrouperClientWs.mostRecentRequest,
36549 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36550 assertTrue(GrouperClientWs.mostRecentRequest,
36551 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36552 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36553 assertTrue(GrouperClientWs.mostRecentRequest,
36554 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36555 assertTrue(GrouperClientWs.mostRecentRequest,
36556 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36557 assertTrue(GrouperClientWs.mostRecentRequest,
36558 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36559 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36560 assertTrue(GrouperClientWs.mostRecentRequest,
36561 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36562 assertTrue(GrouperClientWs.mostRecentRequest,
36563 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36564 assertTrue(GrouperClientWs.mostRecentRequest,
36565 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36566 assertTrue(GrouperClientWs.mostRecentRequest,
36567 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36568
36569
36570
36571
36572
36573 baos = new ByteArrayOutputStream();
36574 System.setOut(new PrintStream(baos));
36575
36576 GrouperClient.main(GrouperClientUtils.splitTrim(
36577 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36578 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36579 + " --entry_0_delegatable=FALSE",
36580 " "));
36581
36582 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36583
36584 System.out.flush();
36585 output = new String(baos.toByteArray());
36586
36587 System.setOut(systemOut);
36588
36589 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36590
36591 outputLine = outputLines[0];
36592
36593 matcher = pattern.matcher(outputLines[0]);
36594
36595 assertTrue(outputLine, matcher.matches());
36596 assertEquals(outputLine, "0", matcher.group(1));
36597 assertEquals(outputLine, "0", matcher.group(2));
36598 assertEquals(outputLine, "group", matcher.group(3));
36599 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36600 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36601 assertEquals(outputLine, "assign", matcher.group(6));
36602 assertEquals(outputLine, "none", matcher.group(7));
36603 assertEquals(outputLine, "T", matcher.group(8));
36604 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36605 assertEquals(outputLine, "T", matcher.group(10));
36606 assertEquals(outputLine, "F", matcher.group(11));
36607
36608 assertTrue(GrouperClientWs.mostRecentRequest,
36609 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36610 assertTrue(GrouperClientWs.mostRecentRequest,
36611 !GrouperClientWs.mostRecentRequest.contains("action"));
36612 assertTrue(GrouperClientWs.mostRecentRequest,
36613 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36614 assertTrue(GrouperClientWs.mostRecentRequest,
36615 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36616
36617
36618 assertTrue(GrouperClientWs.mostRecentRequest,
36619 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36620 assertTrue(GrouperClientWs.mostRecentRequest,
36621 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36622 assertTrue(GrouperClientWs.mostRecentRequest,
36623 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36624 assertTrue(GrouperClientWs.mostRecentRequest,
36625 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36626 assertTrue(GrouperClientWs.mostRecentRequest,
36627 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36628 assertTrue(GrouperClientWs.mostRecentRequest,
36629 GrouperClientWs.mostRecentRequest.contains("delegatable")
36630 && GrouperClientWs.mostRecentRequest.contains("FALSE"));
36631 assertTrue(GrouperClientWs.mostRecentRequest,
36632 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36633 assertTrue(GrouperClientWs.mostRecentRequest,
36634 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36635 assertTrue(GrouperClientWs.mostRecentRequest,
36636 !GrouperClientWs.mostRecentRequest.contains("params"));
36637 assertTrue(GrouperClientWs.mostRecentRequest,
36638 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36639 assertTrue(GrouperClientWs.mostRecentRequest,
36640 !GrouperClientWs.mostRecentRequest.contains("values"));
36641 assertTrue(GrouperClientWs.mostRecentRequest,
36642 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36643 assertTrue(GrouperClientWs.mostRecentRequest,
36644 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36645 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36646 assertTrue(GrouperClientWs.mostRecentRequest,
36647 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36648 assertTrue(GrouperClientWs.mostRecentRequest,
36649 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36650 assertTrue(GrouperClientWs.mostRecentRequest,
36651 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36652 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36653 assertTrue(GrouperClientWs.mostRecentRequest,
36654 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36655 assertTrue(GrouperClientWs.mostRecentRequest,
36656 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36657 assertTrue(GrouperClientWs.mostRecentRequest,
36658 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36659 assertTrue(GrouperClientWs.mostRecentRequest,
36660 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36661
36662
36663
36664
36665 baos = new ByteArrayOutputStream();
36666 System.setOut(new PrintStream(baos));
36667
36668 GrouperClient.main(GrouperClientUtils.splitTrim(
36669 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36670 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36671 + " --entry_0_action=assign",
36672 " "));
36673
36674 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36675
36676 System.out.flush();
36677 output = new String(baos.toByteArray());
36678
36679 System.setOut(systemOut);
36680
36681 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36682
36683 outputLine = outputLines[0];
36684
36685 matcher = pattern.matcher(outputLines[0]);
36686
36687 assertTrue(outputLine, matcher.matches());
36688 assertEquals(outputLine, "0", matcher.group(1));
36689 assertEquals(outputLine, "0", matcher.group(2));
36690 assertEquals(outputLine, "group", matcher.group(3));
36691 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36692 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36693 assertEquals(outputLine, "assign", matcher.group(6));
36694 assertEquals(outputLine, "none", matcher.group(7));
36695 assertEquals(outputLine, "T", matcher.group(8));
36696 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36697 assertEquals(outputLine, "F", matcher.group(10));
36698 assertEquals(outputLine, "F", matcher.group(11));
36699
36700 assertTrue(GrouperClientWs.mostRecentRequest,
36701 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36702 assertTrue(GrouperClientWs.mostRecentRequest,
36703 GrouperClientWs.mostRecentRequest.contains("action"));
36704 assertTrue(GrouperClientWs.mostRecentRequest,
36705 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36706 assertTrue(GrouperClientWs.mostRecentRequest,
36707 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36708
36709
36710 assertTrue(GrouperClientWs.mostRecentRequest,
36711 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36712 assertTrue(GrouperClientWs.mostRecentRequest,
36713 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36714 assertTrue(GrouperClientWs.mostRecentRequest,
36715 !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36716 assertTrue(GrouperClientWs.mostRecentRequest,
36717 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36718 assertTrue(GrouperClientWs.mostRecentRequest,
36719 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36720 assertTrue(GrouperClientWs.mostRecentRequest,
36721 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36722 assertTrue(GrouperClientWs.mostRecentRequest,
36723 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36724 assertTrue(GrouperClientWs.mostRecentRequest,
36725 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36726 assertTrue(GrouperClientWs.mostRecentRequest,
36727 !GrouperClientWs.mostRecentRequest.contains("params"));
36728 assertTrue(GrouperClientWs.mostRecentRequest,
36729 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36730 assertTrue(GrouperClientWs.mostRecentRequest,
36731 !GrouperClientWs.mostRecentRequest.contains("values"));
36732 assertTrue(GrouperClientWs.mostRecentRequest,
36733 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36734 assertTrue(GrouperClientWs.mostRecentRequest,
36735 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36736 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36737 assertTrue(GrouperClientWs.mostRecentRequest,
36738 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36739 assertTrue(GrouperClientWs.mostRecentRequest,
36740 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36741 assertTrue(GrouperClientWs.mostRecentRequest,
36742 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36743 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36744 assertTrue(GrouperClientWs.mostRecentRequest,
36745 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36746 assertTrue(GrouperClientWs.mostRecentRequest,
36747 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36748 assertTrue(GrouperClientWs.mostRecentRequest,
36749 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36750 assertTrue(GrouperClientWs.mostRecentRequest,
36751 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36752
36753
36754
36755
36756 baos = new ByteArrayOutputStream();
36757 System.setOut(new PrintStream(baos));
36758
36759 GrouperClient.main(GrouperClientUtils.splitTrim(
36760 "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36761 "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36762 + " --entry_0_values0System=3 --entry_0_values1System=4 --entry_0_values2System=5 --entry_0_attributeAssignValueOperation=replace_values",
36763 " "));
36764
36765 attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36766
36767 System.out.flush();
36768 output = new String(baos.toByteArray());
36769
36770 System.setOut(systemOut);
36771
36772 outputLines = GrouperClientUtils.splitTrim(output, "\n");
36773
36774 outputLine = outputLines[0];
36775
36776 matcher = pattern.matcher(outputLines[0]);
36777
36778 assertTrue(outputLine, matcher.matches());
36779 assertEquals(outputLine, "0", matcher.group(1));
36780 assertEquals(outputLine, "0", matcher.group(2));
36781 assertEquals(outputLine, "group", matcher.group(3));
36782 assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36783 assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36784 assertEquals(outputLine, "assign", matcher.group(6));
36785 assertEquals(outputLine, "3,4,5", matcher.group(7));
36786 assertEquals(outputLine, "T", matcher.group(8));
36787 assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36788 assertEquals(outputLine, "F", matcher.group(10));
36789 assertEquals(outputLine, "F", matcher.group(11));
36790 assertEquals(outputLine, "T", matcher.group(12));
36791
36792 assertTrue(GrouperClientWs.mostRecentRequest,
36793 !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36794 assertTrue(GrouperClientWs.mostRecentRequest,
36795 !GrouperClientWs.mostRecentRequest.contains("action"));
36796 assertTrue(GrouperClientWs.mostRecentRequest,
36797 !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36798 assertTrue(GrouperClientWs.mostRecentRequest,
36799 !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36800
36801
36802 assertTrue(GrouperClientWs.mostRecentRequest,
36803 !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36804 assertTrue(GrouperClientWs.mostRecentRequest,
36805 GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36806 assertTrue(GrouperClientWs.mostRecentRequest,
36807 GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36808 assertTrue(GrouperClientWs.mostRecentRequest,
36809 GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36810 assertTrue(GrouperClientWs.mostRecentRequest,
36811 !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36812 assertTrue(GrouperClientWs.mostRecentRequest,
36813 !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36814 assertTrue(GrouperClientWs.mostRecentRequest,
36815 !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36816 assertTrue(GrouperClientWs.mostRecentRequest,
36817 !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36818 assertTrue(GrouperClientWs.mostRecentRequest,
36819 !GrouperClientWs.mostRecentRequest.contains("params"));
36820 assertTrue(GrouperClientWs.mostRecentRequest,
36821 !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36822 assertTrue(GrouperClientWs.mostRecentRequest,
36823 GrouperClientWs.mostRecentRequest.contains("values")
36824 && GrouperClientWs.mostRecentRequest.contains(">3<")
36825 && GrouperClientWs.mostRecentRequest.contains(">4<")
36826 && GrouperClientWs.mostRecentRequest.contains(">5<"));
36827 assertTrue(GrouperClientWs.mostRecentRequest,
36828 !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36829 assertTrue(GrouperClientWs.mostRecentRequest,
36830 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36831 && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36832 assertTrue(GrouperClientWs.mostRecentRequest,
36833 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36834 assertTrue(GrouperClientWs.mostRecentRequest,
36835 !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36836 assertTrue(GrouperClientWs.mostRecentRequest,
36837 GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36838 && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36839 assertTrue(GrouperClientWs.mostRecentRequest,
36840 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36841 assertTrue(GrouperClientWs.mostRecentRequest,
36842 !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36843 assertTrue(GrouperClientWs.mostRecentRequest,
36844 !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36845 assertTrue(GrouperClientWs.mostRecentRequest,
36846 !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36847
36848
36849
36850
36851
36852
36853
36854
36855
36856
36857
36858
36859
36860
36861
36862
36863
36864
36865
36866
36867
36868
36869
36870
36871
36872
36873
36874
36875
36876
36877
36878
36879
36880
36881
36882
36883
36884
36885
36886
36887
36888
36889
36890
36891
36892
36893
36894
36895
36896
36897
36898
36899
36900
36901
36902
36903
36904
36905
36906
36907
36908
36909
36910
36911
36912
36913
36914
36915
36916
36917
36918
36919
36920
36921
36922
36923
36924
36925
36926
36927
36928
36929
36930
36931
36932
36933
36934
36935
36936
36937
36938
36939
36940
36941
36942
36943
36944
36945
36946
36947
36948
36949
36950
36951
36952
36953
36954
36955
36956
36957
36958
36959
36960
36961
36962
36963
36964
36965
36966
36967
36968
36969
36970
36971
36972
36973
36974
36975
36976
36977
36978
36979
36980
36981
36982
36983
36984
36985
36986
36987
36988
36989
36990
36991
36992
36993
36994
36995
36996
36997
36998
36999
37000
37001
37002
37003
37004
37005
37006
37007
37008
37009
37010
37011
37012
37013
37014
37015
37016
37017
37018
37019
37020
37021
37022
37023
37024
37025
37026
37027
37028
37029
37030
37031
37032
37033
37034
37035
37036
37037
37038
37039
37040
37041
37042
37043
37044
37045
37046
37047
37048
37049
37050
37051
37052
37053
37054
37055
37056
37057
37058
37059
37060
37061
37062
37063
37064
37065
37066
37067
37068
37069
37070
37071
37072
37073
37074
37075
37076
37077
37078
37079
37080
37081
37082
37083
37084
37085
37086
37087
37088
37089
37090
37091
37092
37093
37094
37095
37096
37097
37098
37099
37100
37101
37102
37103
37104
37105
37106
37107
37108
37109
37110
37111
37112
37113
37114
37115
37116
37117
37118
37119
37120
37121
37122
37123
37124
37125
37126
37127
37128
37129
37130
37131
37132
37133
37134
37135
37136
37137
37138
37139
37140
37141
37142
37143
37144
37145
37146
37147
37148
37149
37150
37151
37152
37153
37154
37155
37156
37157
37158
37159
37160
37161
37162
37163
37164
37165
37166
37167
37168
37169
37170
37171
37172
37173
37174
37175
37176
37177
37178
37179
37180
37181
37182
37183
37184
37185
37186
37187
37188
37189
37190
37191
37192
37193
37194
37195
37196
37197
37198
37199
37200
37201
37202
37203
37204
37205
37206
37207
37208
37209
37210
37211
37212
37213
37214
37215
37216
37217
37218
37219
37220
37221
37222
37223
37224
37225
37226
37227
37228
37229
37230
37231
37232
37233
37234
37235
37236
37237
37238
37239
37240
37241
37242
37243
37244
37245
37246
37247
37248
37249
37250
37251
37252
37253
37254
37255
37256
37257
37258
37259
37260
37261
37262
37263
37264
37265
37266
37267
37268
37269
37270
37271
37272
37273
37274
37275
37276
37277
37278
37279
37280
37281
37282
37283
37284
37285
37286
37287
37288
37289
37290
37291
37292
37293
37294
37295
37296
37297
37298
37299
37300
37301
37302
37303
37304
37305
37306
37307
37308
37309
37310
37311
37312
37313
37314
37315
37316
37317
37318
37319
37320
37321
37322
37323
37324
37325
37326
37327
37328
37329
37330
37331
37332
37333
37334
37335
37336
37337
37338
37339
37340
37341
37342
37343
37344
37345
37346
37347
37348
37349
37350
37351
37352
37353
37354
37355
37356
37357
37358
37359
37360
37361
37362
37363
37364
37365
37366
37367
37368
37369
37370
37371
37372
37373
37374
37375
37376
37377
37378
37379
37380
37381
37382
37383
37384
37385
37386
37387
37388
37389
37390
37391
37392
37393
37394
37395
37396
37397
37398
37399
37400
37401
37402
37403
37404
37405
37406
37407
37408
37409
37410
37411
37412
37413
37414
37415
37416
37417
37418
37419
37420
37421
37422
37423
37424
37425
37426
37427
37428
37429
37430
37431
37432
37433
37434
37435
37436
37437
37438
37439
37440
37441
37442
37443
37444
37445
37446
37447
37448
37449
37450
37451
37452
37453
37454
37455
37456
37457
37458
37459
37460
37461
37462
37463
37464
37465
37466
37467
37468
37469
37470
37471
37472
37473
37474
37475
37476
37477
37478
37479
37480
37481
37482
37483
37484
37485
37486 } finally {
37487 System.setOut(systemOut);
37488 }
37489
37490 }
37491
37492
37493
37494
37495 public void testFindAttributeDefNamesServiceRole() throws Exception {
37496
37497 PrintStream systemOut = System.out;
37498
37499 ByteArrayOutputStream baos = new ByteArrayOutputStream();
37500 System.setOut(new PrintStream(baos));
37501 String output = null;
37502 String[] outputLines = null;
37503 Pattern pattern = null;
37504 Matcher matcher = null;
37505 try {
37506
37507 GrouperSession grouperSession = GrouperSession.startRootSession();
37508
37509 AttributeDefName jiraService = null;
37510 AttributeDefName confluenceService = null;
37511 try {
37512
37513
37514 AttributeDef jiraServiceDef = new AttributeDefSave(grouperSession)
37515 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
37516 .assignName("apps:jira:jiraServiceDefinition").assignToStem(true).save();
37517
37518 jiraService = new AttributeDefNameSave(grouperSession, jiraServiceDef)
37519 .assignCreateParentStemsIfNotExist(true)
37520 .assignName("apps:jira:jiraService").assignDisplayExtension("Central IT production Jira issue tracker").save();
37521
37522
37523 Group jiraGroup = new GroupSave(grouperSession)
37524 .assignName("apps:jira:groups:admins").assignCreateParentStemsIfNotExist(true).save();
37525
37526 jiraGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
37527 jiraGroup.grantPriv(SubjectTestHelper.SUBJ5, AccessPrivilege.READ);
37528 jiraGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.ADMIN);
37529
37530 jiraGroup.addMember(SubjectTestHelper.SUBJ0);
37531 jiraGroup.addMember(SubjectTestHelper.SUBJ1);
37532
37533
37534 Stem jiraStem = StemFinder.findByUuid(grouperSession, jiraGroup.getStemId(), true);
37535 jiraStem.getAttributeDelegate().assignAttribute(jiraService);
37536
37537 AttributeDef confluenceServiceDef = new AttributeDefSave(grouperSession)
37538 .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
37539 .assignName("apps:confluence:confluenceServiceDefinition").assignToStem(true).save();
37540
37541 confluenceService = new AttributeDefNameSave(grouperSession, confluenceServiceDef)
37542 .assignCreateParentStemsIfNotExist(true)
37543 .assignName("apps:confluence:confluenceService").assignDisplayExtension("Central IT production Confluence wiki").save();
37544
37545 Group confluenceGroup = new GroupSave(grouperSession)
37546 .assignName("apps:confluence:editors").assignCreateParentStemsIfNotExist(true).save();
37547
37548 confluenceGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
37549 confluenceGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.READ);
37550 confluenceGroup.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.ADMIN);
37551 confluenceGroup.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN);
37552
37553 confluenceGroup.addMember(SubjectTestHelper.SUBJ1);
37554 confluenceGroup.addMember(SubjectTestHelper.SUBJ2);
37555
37556
37557 Stem confluenceFolder = StemFinder.findByName(grouperSession, "apps:confluence", true);
37558 confluenceFolder.getAttributeDelegate().assignAttribute(confluenceService);
37559
37560 } finally {
37561 GrouperSession.stopQuietly(grouperSession);
37562 }
37563
37564
37565
37566 GrouperClient.main(GrouperClientUtils.splitTrim(
37567 "--operation=findAttributeDefNamesWs --scope=% --serviceRole=user --subjectId=" + SubjectTestHelper.SUBJ0_ID , " "));
37568 System.out.flush();
37569 output = new String(baos.toByteArray());
37570
37571 systemOut.println(output);
37572
37573 System.setOut(systemOut);
37574
37575 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37576
37577 assertEquals(1, outputLines.length);
37578
37579
37580 pattern = Pattern.compile("^Index (\\d+): name: (.*), displayName: (.*)$");
37581 matcher = pattern.matcher(outputLines[0]);
37582
37583 assertTrue(outputLines[0], matcher.matches());
37584
37585 assertEquals(outputLines[0], "0", matcher.group(1));
37586 assertEquals(outputLines[0], jiraService.getName(), matcher.group(2));
37587 assertEquals(outputLines[0], jiraService.getDisplayName(), matcher.group(3));
37588
37589 assertTrue(GrouperClientWs.mostRecentRequest,
37590 GrouperClientWs.mostRecentRequest.contains("serviceRole"));
37591 assertTrue(GrouperClientWs.mostRecentRequest,
37592 GrouperClientWs.mostRecentRequest.contains("<subjectId>"));
37593
37594
37595
37596 baos = new ByteArrayOutputStream();
37597
37598 System.setOut(new PrintStream(baos));
37599
37600 GrouperClient.main(GrouperClientUtils.splitTrim(
37601 "--operation=findAttributeDefNamesWs --scope=% --serviceRole=user --subjectIdentifier=" + SubjectTestHelper.SUBJ1_IDENTIFIER + " --subjectSource=jdbc" , " "));
37602 System.out.flush();
37603 output = new String(baos.toByteArray());
37604
37605 systemOut.println(output);
37606
37607 System.setOut(systemOut);
37608
37609 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37610
37611 assertEquals(2, outputLines.length);
37612
37613
37614 pattern = Pattern.compile("^Index (\\d+): name: (.*), displayName: (.*)$");
37615 matcher = pattern.matcher(outputLines[0]);
37616
37617 assertTrue(outputLines[0], matcher.matches());
37618
37619 assertEquals(outputLines[0], "0", matcher.group(1));
37620 assertEquals(outputLines[0], confluenceService.getName(), matcher.group(2));
37621 assertEquals(outputLines[0], confluenceService.getDisplayName(), matcher.group(3));
37622
37623 matcher = pattern.matcher(outputLines[1]);
37624 assertTrue(outputLines[1], matcher.matches());
37625
37626 assertEquals(outputLines[1], "1", matcher.group(1));
37627 assertEquals(outputLines[1], jiraService.getName(), matcher.group(2));
37628 assertEquals(outputLines[1], jiraService.getDisplayName(), matcher.group(3));
37629
37630 assertTrue(GrouperClientWs.mostRecentRequest,
37631 GrouperClientWs.mostRecentRequest.contains("serviceRole"));
37632 assertTrue(GrouperClientWs.mostRecentRequest,
37633 GrouperClientWs.mostRecentRequest.contains("subjectIdentifier"));
37634 assertFalse(GrouperClientWs.mostRecentRequest,
37635 GrouperClientWs.mostRecentRequest.contains("<subjectId>"));
37636 assertTrue(GrouperClientWs.mostRecentRequest,
37637 GrouperClientWs.mostRecentRequest.contains("subjectSourceId"));
37638
37639
37640
37641 } finally {
37642 System.setOut(systemOut);
37643 }
37644
37645 }
37646
37647
37648
37649
37650 public void testAttributeDefSave() throws Exception {
37651
37652 PrintStream systemOut = System.out;
37653
37654 ByteArrayOutputStream baos = new ByteArrayOutputStream();
37655 System.setOut(new PrintStream(baos));
37656 String output = null;
37657 String[] outputLines = null;
37658 Pattern pattern = null;
37659 Matcher matcher = null;
37660 try {
37661
37662 GrouperSession grouperSession = GrouperSession.startRootSession();
37663
37664 GrouperClient.main(GrouperClientUtils.splitTrim(
37665 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37666 " "));
37667 System.out.flush();
37668 output = new String(baos.toByteArray());
37669
37670 systemOut.println(output);
37671
37672 System.setOut(systemOut);
37673
37674 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37675
37676 assertEquals(1, outputLines.length);
37677
37678 pattern = Pattern.compile("^Success: (T|F): code: ([A-Z_]+): (.*+)$");
37679 matcher = pattern.matcher(outputLines[0]);
37680
37681 assertTrue(outputLines[0], matcher.matches());
37682
37683 assertEquals(outputLines[0], "T", matcher.group(1));
37684 assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
37685 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37686
37687
37688
37689
37690 baos = new ByteArrayOutputStream();
37691 System.setOut(new PrintStream(baos));
37692
37693 GrouperClient.main(GrouperClientUtils.splitTrim(
37694 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef0/1 --createParentStemsIfNotExist=T --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37695 " "));
37696
37697 System.out.flush();
37698 output = new String(baos.toByteArray());
37699
37700 System.setOut(systemOut);
37701
37702 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37703
37704 assertEquals(1, outputLines.length);
37705
37706 matcher = pattern.matcher(outputLines[0]);
37707
37708 assertTrue(outputLines[0], matcher.matches());
37709
37710 assertEquals(outputLines[0], "T", matcher.group(1));
37711 assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
37712 assertEquals(outputLines[0], "aStem:newAttributeDef0/1", matcher.group(3));
37713
37714 assertFalse(GrouperClientWs.mostRecentRequest,
37715 GrouperClientWs.mostRecentRequest.contains("saveMode"));
37716
37717
37718
37719
37720 baos = new ByteArrayOutputStream();
37721 System.setOut(new PrintStream(baos));
37722
37723 GrouperClient.main(GrouperClientUtils.splitTrim(
37724 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef0/1 --createParentStemsIfNotExist=T "
37725 + "--attributeDefType=attr --valueType=string --assignToAttributeDef=T --saveMode=UPDATE",
37726 " "));
37727
37728 System.out.flush();
37729 output = new String(baos.toByteArray());
37730
37731 System.setOut(systemOut);
37732
37733 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37734
37735 assertEquals(1, outputLines.length);
37736
37737 matcher = pattern.matcher(outputLines[0]);
37738
37739 assertTrue(outputLines[0], matcher.matches());
37740
37741 assertEquals(outputLines[0], "T", matcher.group(1));
37742 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37743 assertEquals(outputLines[0], "aStem:newAttributeDef0/1", matcher.group(3));
37744
37745 assertTrue(GrouperClientWs.mostRecentRequest,
37746 GrouperClientWs.mostRecentRequest.contains("saveMode")
37747 && GrouperClientWs.mostRecentRequest.contains(">UPDATE<"));
37748 assertFalse(GrouperClientWs.mostRecentRequest,
37749 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
37750
37751
37752
37753
37754 baos = new ByteArrayOutputStream();
37755 System.setOut(new PrintStream(baos));
37756
37757 GrouperClient.main(GrouperClientUtils.splitTrim(
37758 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37759 + "--attributeDefLookupName=aStem:newAttributeDef --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37760 " "));
37761
37762 System.out.flush();
37763 output = new String(baos.toByteArray());
37764
37765 System.setOut(systemOut);
37766
37767 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37768
37769 assertEquals(1, outputLines.length);
37770
37771 matcher = pattern.matcher(outputLines[0]);
37772
37773 assertTrue(outputLines[0], matcher.matches());
37774
37775 assertEquals(outputLines[0], "T", matcher.group(1));
37776 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37777 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37778
37779 assertFalse(GrouperClientWs.mostRecentRequest,
37780 GrouperClientWs.mostRecentRequest.contains("saveMode"));
37781 assertTrue(GrouperClientWs.mostRecentRequest,
37782 GrouperClientWs.mostRecentRequest.contains("createParentStemsIfNotExist"));
37783 assertTrue(GrouperClientWs.mostRecentRequest,
37784 GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefLookup>"));
37785
37786
37787
37788
37789 AttributeDef newAttributeDef = AttributeDefFinder
37790 .findByName("aStem:newAttributeDef", true);
37791
37792 baos = new ByteArrayOutputStream();
37793 System.setOut(new PrintStream(baos));
37794
37795 GrouperClient.main(GrouperClientUtils.splitTrim(
37796 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37797 + "--attributeDefLookupUuid=" + newAttributeDef.getId()
37798 + " --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37799 " "));
37800
37801 System.out.flush();
37802 output = new String(baos.toByteArray());
37803
37804 System.setOut(systemOut);
37805
37806 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37807
37808 assertEquals(1, outputLines.length);
37809
37810 matcher = pattern.matcher(outputLines[0]);
37811
37812 assertTrue(outputLines[0], matcher.matches());
37813
37814 assertEquals(outputLines[0], "T", matcher.group(1));
37815 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37816 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37817
37818 assertFalse(GrouperClientWs.mostRecentRequest,
37819 GrouperClientWs.mostRecentRequest.contains("description"));
37820 assertTrue(GrouperClientWs.mostRecentRequest,
37821 GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefLookup>")
37822 && GrouperClientWs.mostRecentRequest.contains(newAttributeDef.getId()));
37823
37824
37825
37826
37827 baos = new ByteArrayOutputStream();
37828 System.setOut(new PrintStream(baos));
37829
37830 GrouperClient.main(GrouperClientUtils.splitTrim(
37831 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37832 + "--attributeDefLookupIdIndex=" + newAttributeDef.getIdIndex()
37833 + " --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37834 " "));
37835
37836 System.out.flush();
37837 output = new String(baos.toByteArray());
37838
37839 System.setOut(systemOut);
37840
37841 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37842
37843 assertEquals(1, outputLines.length);
37844
37845 matcher = pattern.matcher(outputLines[0]);
37846
37847 assertTrue(outputLines[0], matcher.matches());
37848
37849 assertEquals(outputLines[0], "T", matcher.group(1));
37850 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37851 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37852
37853 assertFalse(GrouperClientWs.mostRecentRequest,
37854 GrouperClientWs.mostRecentRequest.contains("description"));
37855 assertTrue(GrouperClientWs.mostRecentRequest,
37856 GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefLookup>")
37857 && GrouperClientWs.mostRecentRequest
37858 .contains(newAttributeDef.getIdIndex().toString()));
37859
37860
37861
37862
37863 baos = new ByteArrayOutputStream();
37864 System.setOut(new PrintStream(baos));
37865
37866 GrouperClient.main(GrouperClientUtils.splitTrim(
37867 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37868 + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37869 " "));
37870
37871 System.out.flush();
37872 output = new String(baos.toByteArray());
37873
37874 System.setOut(systemOut);
37875
37876 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37877
37878 assertEquals(1, outputLines.length);
37879
37880 matcher = pattern.matcher(outputLines[0]);
37881
37882 assertTrue(outputLines[0], matcher.matches());
37883
37884 assertEquals(outputLines[0], "T", matcher.group(1));
37885 assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
37886 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37887
37888 assertTrue(GrouperClientWs.mostRecentRequest,
37889 GrouperClientWs.mostRecentRequest.contains("<description>")
37890 && GrouperClientWs.mostRecentRequest.contains("theDescription"));
37891
37892
37893
37894
37895 baos = new ByteArrayOutputStream();
37896 System.setOut(new PrintStream(baos));
37897
37898 GrouperClient.main(GrouperClientUtils.splitTrim(
37899 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef5 --idIndex=12345 --createParentStemsIfNotExist=T "
37900 + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37901 " "));
37902
37903 System.out.flush();
37904 output = new String(baos.toByteArray());
37905
37906 System.setOut(systemOut);
37907
37908 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37909
37910 assertEquals(1, outputLines.length);
37911
37912 matcher = pattern.matcher(outputLines[0]);
37913
37914 assertTrue(outputLines[0], matcher.matches());
37915
37916 assertEquals(outputLines[0], "T", matcher.group(1));
37917 assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
37918 assertEquals(outputLines[0], "aStem:newAttributeDef5", matcher.group(3));
37919
37920 assertTrue(GrouperClientWs.mostRecentRequest,
37921 GrouperClientWs.mostRecentRequest.contains("<idIndex>")
37922 && GrouperClientWs.mostRecentRequest.contains("12345"));
37923 assertTrue(GrouperClientWs.mostRecentResponse,
37924 GrouperClientWs.mostRecentResponse.contains("<idIndex>12345"));
37925
37926
37927
37928
37929 baos = new ByteArrayOutputStream();
37930 System.setOut(new PrintStream(baos));
37931
37932 GrouperClient.main(GrouperClientUtils.splitTrim(
37933 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --actAsSubjectId=GrouperSystem --createParentStemsIfNotExist=T "
37934 + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37935 " "));
37936
37937 System.out.flush();
37938 output = new String(baos.toByteArray());
37939
37940 System.setOut(systemOut);
37941
37942 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37943
37944 assertEquals(1, outputLines.length);
37945
37946 matcher = pattern.matcher(outputLines[0]);
37947
37948 assertTrue(outputLines[0], matcher.matches());
37949
37950 assertEquals(outputLines[0], "T", matcher.group(1));
37951 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37952 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37953
37954 assertFalse(GrouperClientWs.mostRecentRequest,
37955 GrouperClientWs.mostRecentRequest.contains("subjectIdentifier"));
37956 assertTrue(GrouperClientWs.mostRecentRequest,
37957 GrouperClientWs.mostRecentRequest.contains("<actAsSubjectLookup><subjectId>"));
37958
37959
37960
37961
37962 baos = new ByteArrayOutputStream();
37963 System.setOut(new PrintStream(baos));
37964
37965 GrouperClient.main(GrouperClientUtils.splitTrim(
37966 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --actAsSubjectIdentifier=GrouperSystem --createParentStemsIfNotExist=T "
37967 + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37968 " "));
37969
37970 System.out.flush();
37971 output = new String(baos.toByteArray());
37972
37973 System.setOut(systemOut);
37974
37975 outputLines = GrouperClientUtils.splitTrim(output, "\n");
37976
37977 assertEquals(1, outputLines.length);
37978
37979 matcher = pattern.matcher(outputLines[0]);
37980
37981 assertTrue(outputLines[0], matcher.matches());
37982
37983 assertEquals(outputLines[0], "T", matcher.group(1));
37984 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37985 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37986
37987 assertFalse(GrouperClientWs.mostRecentRequest,
37988 GrouperClientWs.mostRecentRequest.contains("sourceId"));
37989 assertTrue(GrouperClientWs.mostRecentRequest,
37990 GrouperClientWs.mostRecentRequest
37991 .contains("<actAsSubjectLookup><subjectIdentifier>"));
37992
37993
37994
37995
37996 baos = new ByteArrayOutputStream();
37997 System.setOut(new PrintStream(baos));
37998
37999 GrouperClient.main(GrouperClientUtils.splitTrim(
38000 "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --actAsSubjectIdentifier=GrouperSystem"
38001 + " --actAsSubjectSource=g:isa --createParentStemsIfNotExist=T"
38002 + " --description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
38003 " "));
38004
38005 System.out.flush();
38006 output = new String(baos.toByteArray());
38007
38008 System.setOut(systemOut);
38009
38010 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38011
38012 assertEquals(1, outputLines.length);
38013
38014 matcher = pattern.matcher(outputLines[0]);
38015
38016 assertTrue(outputLines[0], matcher.matches());
38017
38018 assertEquals(outputLines[0], "T", matcher.group(1));
38019 assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
38020 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
38021
38022 assertFalse(GrouperClientWs.mostRecentRequest,
38023 GrouperClientWs.mostRecentRequest.contains("somethingelse"));
38024 assertTrue(GrouperClientWs.mostRecentRequest,
38025 GrouperClientWs.mostRecentRequest.contains("subjectSourceId")
38026 && GrouperClientWs.mostRecentRequest.contains("g:isa"));
38027
38028 } finally {
38029 System.setOut(systemOut);
38030 }
38031
38032 }
38033
38034
38035
38036
38037 public void testAttributeDefDelete() throws Exception {
38038
38039 PrintStream systemOut = System.out;
38040
38041 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38042 System.setOut(new PrintStream(baos));
38043 String output = null;
38044 String[] outputLines = null;
38045 Pattern pattern = null;
38046 Matcher matcher = null;
38047 try {
38048
38049 GrouperSession grouperSession = GrouperSession.startRootSession();
38050
38051 AttributeDef testAttributeDef1 = new AttributeDefSave(grouperSession)
38052 .assignName("aStem:newAttributeDef")
38053 .assignAttributeDefType(AttributeDefType.perm).assignToGroup(true)
38054 .assignToEffMembership(true).save();
38055
38056 GrouperClient.main(GrouperClientUtils.splitTrim(
38057 "--operation=attributeDefDeleteWs --attributeDefNames=aStem:newAttributeDef,aStem:newAttributeDef2",
38058 " "));
38059 System.out.flush();
38060 output = new String(baos.toByteArray());
38061
38062 systemOut.println(output);
38063
38064 System.setOut(systemOut);
38065
38066 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38067
38068 assertEquals(2, outputLines.length);
38069
38070 pattern = Pattern.compile("^Index (\\d+): success: (T|F): code: ([A-Z_]+): (.*+)$");
38071 matcher = pattern.matcher(outputLines[0]);
38072
38073 assertTrue(outputLines[0], matcher.matches());
38074
38075 assertEquals(outputLines[0], "0", matcher.group(1));
38076 assertEquals(outputLines[0], "T", matcher.group(2));
38077 assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
38078 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(4));
38079
38080 matcher = pattern.matcher(outputLines[1]);
38081
38082 assertTrue(outputLines[1], matcher.matches());
38083
38084 assertEquals(outputLines[1], "1", matcher.group(1));
38085 assertEquals(outputLines[1], "T", matcher.group(2));
38086 assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NOT_FOUND", matcher.group(3));
38087 assertEquals(outputLines[1], "aStem:newAttributeDef2", matcher.group(4));
38088
38089
38090
38091 baos = new ByteArrayOutputStream();
38092 System.setOut(new PrintStream(baos));
38093
38094 GrouperClient.main(GrouperClientUtils.splitTrim(
38095 "--operation=attributeDefDeleteWs --attributeDefNames=aStem:newAttributeDef,aStem:newAttributeDef2 --txType=READ_WRITE_NEW",
38096 " "));
38097
38098 System.out.flush();
38099 output = new String(baos.toByteArray());
38100
38101 System.setOut(systemOut);
38102
38103 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38104
38105 assertEquals(2, outputLines.length);
38106
38107 matcher = pattern.matcher(outputLines[0]);
38108
38109 assertTrue(outputLines[0], matcher.matches());
38110
38111 assertEquals(outputLines[0], "0", matcher.group(1));
38112 assertEquals(outputLines[0], "T", matcher.group(2));
38113 assertEquals(outputLines[0], "SUCCESS_ATTRIBUTE_DEF_NOT_FOUND", matcher.group(3));
38114 assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(4));
38115
38116 matcher = pattern.matcher(outputLines[1]);
38117
38118 assertTrue(outputLines[1], matcher.matches());
38119
38120 assertEquals(outputLines[1], "1", matcher.group(1));
38121 assertEquals(outputLines[1], "T", matcher.group(2));
38122 assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NOT_FOUND", matcher.group(3));
38123 assertEquals(outputLines[1], "aStem:newAttributeDef2", matcher.group(4));
38124
38125 assertTrue(GrouperClientWs.mostRecentRequest,
38126 GrouperClientWs.mostRecentRequest.contains("txType")
38127 && GrouperClientWs.mostRecentRequest.contains("READ_WRITE_NEW"));
38128
38129 } finally {
38130 System.setOut(systemOut);
38131 }
38132
38133 }
38134
38135
38136
38137
38138 public void testFindAttributeDefs() throws Exception {
38139
38140 PrintStream systemOut = System.out;
38141
38142 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38143 System.setOut(new PrintStream(baos));
38144 String output = null;
38145 String[] outputLines = null;
38146 Pattern pattern = null;
38147 Matcher matcher = null;
38148 try {
38149
38150 GrouperSession grouperSession = GrouperSession.startRootSession();
38151
38152 AttributeDef attributeDef1 = new AttributeDefSave(grouperSession)
38153 .assignName("aStem1:newAttributeDef1")
38154 .assignCreateParentStemsIfNotExist(true)
38155 .assignAttributeDefType(AttributeDefType.perm).assignToGroup(true)
38156 .assignDescription("attribute def 1").save();
38157
38158 AttributeDef attributeDef2 = new AttributeDefSave(grouperSession)
38159 .assignName("aStem1:newAttributeDef2")
38160 .assignCreateParentStemsIfNotExist(true)
38161 .assignAttributeDefType(AttributeDefType.perm).assignToGroup(true)
38162 .assignDescription("attribute def 2").save();
38163
38164 GrouperClient.main(GrouperClientUtils.splitTrim(
38165 "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2 --scope=aStem",
38166 " "));
38167 System.out.flush();
38168 output = new String(baos.toByteArray());
38169
38170 systemOut.println(output);
38171
38172 System.setOut(systemOut);
38173
38174 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38175
38176 assertEquals(2, outputLines.length);
38177
38178
38179 pattern = Pattern.compile("^Index (\\d+): name: (.*), description: (.*)$");
38180 matcher = pattern.matcher(outputLines[0]);
38181
38182 assertTrue(outputLines[0], matcher.matches());
38183
38184 assertEquals(outputLines[0], "0", matcher.group(1));
38185 assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38186 assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38187
38188 assertTrue(GrouperClientWs.mostRecentRequest,
38189 GrouperClientWs.mostRecentRequest.contains("scope"));
38190 assertFalse(GrouperClientWs.mostRecentRequest,
38191 GrouperClientWs.mostRecentRequest.contains("splitScope"));
38192
38193
38194
38195 baos = new ByteArrayOutputStream();
38196
38197 System.setOut(new PrintStream(baos));
38198
38199 GrouperClient.main(GrouperClientUtils.splitTrim(
38200 "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2 --scope=aStem --splitScope=T",
38201 " "));
38202 System.out.flush();
38203 output = new String(baos.toByteArray());
38204
38205 systemOut.println(output);
38206
38207 System.setOut(systemOut);
38208
38209 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38210
38211 assertEquals(2, outputLines.length);
38212
38213
38214 matcher = pattern.matcher(outputLines[0]);
38215
38216 assertTrue(outputLines[0], matcher.matches());
38217
38218 assertEquals(outputLines[0], "0", matcher.group(1));
38219 assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38220 assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38221
38222 assertTrue(GrouperClientWs.mostRecentRequest,
38223 GrouperClientWs.mostRecentRequest.contains("scope"));
38224 assertTrue(GrouperClientWs.mostRecentRequest,
38225 GrouperClientWs.mostRecentRequest.contains("splitScope"));
38226 assertTrue(GrouperClientWs.mostRecentRequest,
38227 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38228
38229
38230
38231 baos = new ByteArrayOutputStream();
38232
38233 System.setOut(new PrintStream(baos));
38234
38235 GrouperClient.main(GrouperClientUtils.splitTrim(
38236 "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2",
38237 " "));
38238 System.out.flush();
38239 output = new String(baos.toByteArray());
38240
38241 systemOut.println(output);
38242
38243 System.setOut(systemOut);
38244
38245 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38246
38247 assertEquals(2, outputLines.length);
38248
38249
38250 matcher = pattern.matcher(outputLines[0]);
38251
38252 assertTrue(outputLines[0], matcher.matches());
38253
38254 assertEquals(outputLines[0], "0", matcher.group(1));
38255 assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38256 assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38257
38258 assertFalse(GrouperClientWs.mostRecentRequest,
38259 GrouperClientWs.mostRecentRequest.contains("scope"));
38260 assertFalse(GrouperClientWs.mostRecentRequest,
38261 GrouperClientWs.mostRecentRequest.contains("splitScope"));
38262 assertTrue(GrouperClientWs.mostRecentRequest,
38263 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38264
38265
38266
38267 baos = new ByteArrayOutputStream();
38268
38269 System.setOut(new PrintStream(baos));
38270
38271 GrouperClient.main(GrouperClientUtils.splitTrim(
38272 "--operation=findAttributeDefsWs --attributeDefUuids=" + attributeDef1.getId()
38273 + "," + attributeDef2.getId(),
38274 " "));
38275 System.out.flush();
38276 output = new String(baos.toByteArray());
38277
38278 systemOut.println(output);
38279
38280 System.setOut(systemOut);
38281
38282 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38283
38284 assertEquals(2, outputLines.length);
38285
38286
38287 matcher = pattern.matcher(outputLines[0]);
38288
38289 assertTrue(outputLines[0], matcher.matches());
38290
38291 assertEquals(outputLines[0], "0", matcher.group(1));
38292 assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38293 assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38294
38295 assertFalse(GrouperClientWs.mostRecentRequest,
38296 GrouperClientWs.mostRecentRequest.contains("scope"));
38297 assertFalse(GrouperClientWs.mostRecentRequest,
38298 GrouperClientWs.mostRecentRequest.contains("splitScope"));
38299 assertTrue(GrouperClientWs.mostRecentRequest,
38300 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38301
38302
38303
38304 baos = new ByteArrayOutputStream();
38305
38306 System.setOut(new PrintStream(baos));
38307
38308 GrouperClient.main(GrouperClientUtils.splitTrim(
38309 "--operation=findAttributeDefsWs --attributeDefIdIndexes="
38310 + attributeDef1.getIdIndex() + "," + attributeDef2.getIdIndex(),
38311 " "));
38312 System.out.flush();
38313 output = new String(baos.toByteArray());
38314
38315 systemOut.println(output);
38316
38317 System.setOut(systemOut);
38318
38319 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38320
38321 assertEquals(2, outputLines.length);
38322
38323
38324 matcher = pattern.matcher(outputLines[0]);
38325
38326 assertTrue(outputLines[0], matcher.matches());
38327
38328 assertEquals(outputLines[0], "0", matcher.group(1));
38329 assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38330 assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38331
38332 assertFalse(GrouperClientWs.mostRecentRequest,
38333 GrouperClientWs.mostRecentRequest.contains("scope"));
38334 assertFalse(GrouperClientWs.mostRecentRequest,
38335 GrouperClientWs.mostRecentRequest.contains("splitScope"));
38336 assertTrue(GrouperClientWs.mostRecentRequest,
38337 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38338
38339
38340
38341 baos = new ByteArrayOutputStream();
38342
38343 System.setOut(new PrintStream(baos));
38344
38345 GrouperClient.main(GrouperClientUtils.splitTrim(
38346 "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2 --scope=aStem --sortString=extension --ascending=T --pageNumber=2 --pageSize=1",
38347 " "));
38348 System.out.flush();
38349 output = new String(baos.toByteArray());
38350
38351 systemOut.println(output);
38352
38353 System.setOut(systemOut);
38354
38355 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38356
38357 assertEquals(1, outputLines.length);
38358
38359
38360 matcher = pattern.matcher(outputLines[0]);
38361
38362 assertTrue(outputLines[0], matcher.matches());
38363
38364 assertEquals(outputLines[0], "0", matcher.group(1));
38365 assertEquals(outputLines[0], "aStem1:newAttributeDef2", matcher.group(2));
38366 assertEquals(outputLines[0], "attribute def 2", matcher.group(3));
38367
38368 assertTrue(GrouperClientWs.mostRecentRequest,
38369 GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38370 assertTrue(GrouperClientWs.mostRecentRequest,
38371 GrouperClientWs.mostRecentRequest.contains("sortString"));
38372 assertTrue(GrouperClientWs.mostRecentRequest,
38373 GrouperClientWs.mostRecentRequest.contains("ascending"));
38374 assertTrue(GrouperClientWs.mostRecentRequest,
38375 GrouperClientWs.mostRecentRequest.contains("pageNumber"));
38376 assertTrue(GrouperClientWs.mostRecentRequest,
38377 GrouperClientWs.mostRecentRequest.contains("pageSize"));
38378
38379 } finally {
38380 System.setOut(systemOut);
38381 }
38382
38383 }
38384
38385
38386
38387
38388 public void testSendMessage() throws Exception {
38389
38390 PrintStream systemOut = System.out;
38391
38392 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38393 System.setOut(new PrintStream(baos));
38394 String output = null;
38395 String[] outputLines = null;
38396 Pattern pattern = null;
38397 Matcher matcher = null;
38398 try {
38399
38400 GrouperSession grouperSession = GrouperSession.startRootSession();
38401 GrouperBuiltinMessagingSystem.createQueue("test_queue");
38402 GrouperBuiltinMessagingSystem.allowSendToQueue("test_queue", SubjectTestHelper.SUBJ0);
38403 GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_queue", SubjectTestHelper.SUBJ0);
38404
38405 GrouperClient.main(GrouperClientUtils.splitTrim(
38406 "--operation=sendMessageWs --queueOrTopic=queue --queueOrTopicName=test_queue --messages=Test_body,Another_test_body --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38407 " "));
38408 System.out.flush();
38409 output = new String(baos.toByteArray());
38410
38411 systemOut.println(output);
38412
38413 System.setOut(systemOut);
38414
38415 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38416
38417 assertEquals(1, outputLines.length);
38418
38419 pattern = Pattern.compile("^Success: (T|F), queueOrTopicName: (.*), numberOfMessages: (.*)$");
38420 matcher = pattern.matcher(outputLines[0]);
38421
38422 assertTrue(outputLines[0], matcher.matches());
38423
38424 assertEquals(outputLines[0], "T", matcher.group(1));
38425 assertEquals(outputLines[0], "test_queue", matcher.group(2));
38426 assertEquals(outputLines[0], "2", matcher.group(3));
38427
38428 assertTrue(GrouperClientWs.mostRecentRequest,
38429 GrouperClientWs.mostRecentRequest.contains("queueOrTopic"));
38430 assertFalse(GrouperClientWs.mostRecentRequest,
38431 GrouperClientWs.mostRecentRequest.contains("messageSystemName"));
38432
38433 } finally {
38434 System.setOut(systemOut);
38435 }
38436
38437 }
38438
38439
38440
38441
38442 public void testReceiveMessage() throws Exception {
38443
38444 PrintStream systemOut = System.out;
38445
38446 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38447 System.setOut(new PrintStream(baos));
38448 String output = null;
38449 String[] outputLines = null;
38450 Pattern pattern = null;
38451 Matcher matcher = null;
38452 try {
38453
38454 GrouperSession grouperSession = GrouperSession.startRootSession();
38455 GrouperBuiltinMessagingSystem.createQueue("test_queue");
38456 GrouperBuiltinMessagingSystem.allowSendToQueue("test_queue", SubjectTestHelper.SUBJ0);
38457 GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_queue", SubjectTestHelper.SUBJ0);
38458
38459 GrouperSession.start(SubjectTestHelper.SUBJ0);
38460 GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38461 .addMessageBody("message body").assignQueueType(GrouperMessageQueueType.queue));
38462
38463 GrouperClient.main(GrouperClientUtils.splitTrim(
38464 "--operation=receiveMessageWs --queueOrTopicName=test_queue --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38465 " "));
38466 System.out.flush();
38467 output = new String(baos.toByteArray());
38468
38469 systemOut.println(output);
38470
38471 System.setOut(systemOut);
38472
38473 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38474
38475 assertEquals(1, outputLines.length);
38476
38477 pattern = Pattern.compile("^Success: (T|F), queueOrTopicName: (.*), numberOfMessages: (\\d+)$");
38478 matcher = pattern.matcher(outputLines[0]);
38479
38480 assertTrue(outputLines[0], matcher.matches());
38481
38482 assertEquals(outputLines[0], "T", matcher.group(1));
38483 assertEquals(outputLines[0], "test_queue", matcher.group(2));
38484 assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) >= 1);
38485
38486
38487
38488 GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38489 .addMessageBody("message body").assignQueueType(GrouperMessageQueueType.queue));
38490 GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38491 .addMessageBody("another message body").assignQueueType(GrouperMessageQueueType.queue));
38492 baos = new ByteArrayOutputStream();
38493
38494 System.setOut(new PrintStream(baos));
38495
38496 GrouperClient.main(GrouperClientUtils.splitTrim(
38497 "--operation=receiveMessageWs --queueOrTopicName=test_queue --maxMessagesToReceiveAtOnce=1 --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38498 " "));
38499 System.out.flush();
38500 output = new String(baos.toByteArray());
38501
38502 systemOut.println(output);
38503
38504 System.setOut(systemOut);
38505
38506 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38507
38508 assertEquals(1, outputLines.length);
38509
38510 matcher = pattern.matcher(outputLines[0]);
38511
38512 assertTrue(outputLines[0], matcher.matches());
38513
38514 assertEquals(outputLines[0], "T", matcher.group(1));
38515 assertEquals(outputLines[0], "test_queue", matcher.group(2));
38516 assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) == 1);
38517
38518 assertTrue(GrouperClientWs.mostRecentRequest,
38519 GrouperClientWs.mostRecentRequest.contains("maxMessagesToReceiveAtOnce"));
38520
38521 } finally {
38522 System.setOut(systemOut);
38523 }
38524
38525 }
38526
38527
38528
38529
38530 public void testAcknowledgeMessage() throws Exception {
38531
38532 PrintStream systemOut = System.out;
38533
38534 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38535 System.setOut(new PrintStream(baos));
38536 String output = null;
38537 String[] outputLines = null;
38538 Pattern pattern = null;
38539 Matcher matcher = null;
38540 try {
38541
38542 GrouperSession grouperSession = GrouperSession.startRootSession();
38543 GrouperBuiltinMessagingSystem.createQueue("test_queue");
38544 GrouperBuiltinMessagingSystem.allowSendToQueue("test_queue", SubjectTestHelper.SUBJ0);
38545 GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_queue", SubjectTestHelper.SUBJ0);
38546
38547 GrouperBuiltinMessagingSystem.createQueue("test_another_queue");
38548 GrouperBuiltinMessagingSystem.allowSendToQueue("test_another_queue", SubjectTestHelper.SUBJ0);
38549 GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_another_queue", SubjectTestHelper.SUBJ0);
38550
38551 GrouperSession.start(SubjectTestHelper.SUBJ0);
38552 GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38553 .addMessageBody("message body").assignQueueType(GrouperMessageQueueType.queue));
38554
38555 GrouperMessageReceiveResult grouperMessageReceiveResult = GrouperMessagingEngine.receive(new GrouperMessageReceiveParam().assignQueueName("test_queue"));
38556
38557 GrouperMessage grouperMessage = grouperMessageReceiveResult.getGrouperMessages().iterator().next();
38558
38559
38560 GrouperClient.main(GrouperClientUtils.splitTrim(
38561 "--operation=acknowledgeMessageWs --queueOrTopicName=test_queue "
38562 + "--acknowledgeType=mark_as_processed --messageIds="+grouperMessage.getId()+" --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38563 " "));
38564 System.out.flush();
38565 output = new String(baos.toByteArray());
38566
38567 systemOut.println(output);
38568
38569 System.setOut(systemOut);
38570
38571 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38572
38573 assertEquals(1, outputLines.length);
38574
38575 pattern = Pattern.compile("^Success: (T|F), queueOrTopicName: (.*), numberOfMessages: (\\d+)$");
38576 matcher = pattern.matcher(outputLines[0]);
38577
38578 assertTrue(outputLines[0], matcher.matches());
38579
38580 assertEquals(outputLines[0], "T", matcher.group(1));
38581 assertEquals(outputLines[0], "test_queue", matcher.group(2));
38582 assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) >= 1);
38583
38584
38585
38586 GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38587 .addMessageBody("message test body").assignQueueType(GrouperMessageQueueType.queue));
38588
38589 grouperMessageReceiveResult = GrouperMessagingEngine.receive(new GrouperMessageReceiveParam().assignQueueName("test_queue"));
38590 grouperMessage = grouperMessageReceiveResult.getGrouperMessages().iterator().next();
38591
38592 baos = new ByteArrayOutputStream();
38593
38594 System.setOut(new PrintStream(baos));
38595
38596 GrouperClient.main(GrouperClientUtils.splitTrim(
38597 "--operation=acknowledgeMessageWs --queueOrTopicName=test_queue "
38598 + "--acknowledgeType=send_to_another_queue --anotherQueueOrTopicName=test_another_queue --anotherQueueOrTopic=queue"
38599 + " --messageIds="+grouperMessage.getId()+" --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38600 " "));
38601 System.out.flush();
38602 output = new String(baos.toByteArray());
38603
38604 systemOut.println(output);
38605
38606 System.setOut(systemOut);
38607
38608 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38609
38610 assertEquals(1, outputLines.length);
38611
38612 matcher = pattern.matcher(outputLines[0]);
38613
38614 assertTrue(outputLines[0], matcher.matches());
38615
38616 assertEquals(outputLines[0], "T", matcher.group(1));
38617 assertEquals(outputLines[0], "test_queue", matcher.group(2));
38618 assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) == 1);
38619
38620 } finally {
38621 System.setOut(systemOut);
38622 }
38623
38624 }
38625
38626
38627
38628
38629 public void testFindExternalSubjects() throws Exception {
38630
38631
38632 GrouperSession grouperSession = GrouperSession.startRootSession();
38633
38634
38635 ExternalSubjectSave assignName = new ExternalSubjectSave(grouperSession).assignEmail("a@b.c")
38636 .assignIdentifier("a_ident@b.c").assignName("Some Name");
38637
38638 boolean hasJabber = StringUtils.equals(GrouperConfig.retrieveConfig().propertyValueString("externalSubjects.attributes.jabber.systemName"), "jabber");
38639
38640 if (hasJabber) {
38641 assignName.addAttribute("jabber", "a_jabber@b.c");
38642 }
38643 ExternalSubject externalSubject = assignName.save();
38644
38645
38646 PrintStream systemOut = System.out;
38647
38648 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38649 System.setOut(new PrintStream(baos));
38650
38651 try {
38652
38653 GrouperClient
38654 .main(GrouperClientUtils
38655 .splitTrim(
38656 "--operation=findExternalSubjectsWs --identifier=a_ident@b.c",
38657 " "));
38658 System.out.flush();
38659 String output = new String(baos.toByteArray());
38660
38661 System.setOut(systemOut);
38662
38663 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
38664
38665 Pattern pattern = Pattern
38666 .compile("^Index (\\d+): identifier: (.+), name: (.+)$");
38667 Matcher matcher = pattern.matcher(outputLines[0]);
38668
38669 assertEquals(output, 1, outputLines.length);
38670 assertTrue(outputLines[0], matcher.matches());
38671
38672 assertEquals(output, "0", matcher.group(1));
38673 assertEquals(output, "a_ident@b.c", matcher.group(2));
38674 assertEquals(output, "Some Name", matcher.group(3));
38675
38676
38677
38678 baos = new ByteArrayOutputStream();
38679 System.setOut(new PrintStream(baos));
38680
38681
38682 try {
38683 GrouperClient
38684 .main(GrouperClientUtils
38685 .splitTrim(
38686 "--operation=findExternalSubjectsWs --identifier=a_ident@b.c --ousdfsdfate=${index}",
38687 " "));
38688 } catch (Exception e) {
38689 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
38690 }
38691 System.out.flush();
38692
38693 System.setOut(systemOut);
38694
38695
38696
38697 baos = new ByteArrayOutputStream();
38698 System.setOut(new PrintStream(baos));
38699
38700
38701 GrouperClient
38702 .main(GrouperClientUtils
38703 .splitTrim(
38704 "--operation=findExternalSubjectsWs --identifier=a_ident@b.c --outputTemplate=${index}",
38705 " "));
38706
38707 System.out.flush();
38708
38709 output = new String(baos.toByteArray());
38710
38711 System.setOut(systemOut);
38712
38713 assertEquals("0", output);
38714
38715
38716
38717 baos = new ByteArrayOutputStream();
38718 System.setOut(new PrintStream(baos));
38719
38720 GrouperClient
38721 .main(GrouperClientUtils
38722 .splitTrim(
38723 "--operation=findExternalSubjectsWs --identifier=a_ident@b.c --paramName0=whatever --paramValue0=someValue",
38724 " "));
38725 System.out.flush();
38726 output = new String(baos.toByteArray());
38727
38728 System.setOut(systemOut);
38729
38730 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38731
38732 matcher = pattern.matcher(outputLines[0]);
38733
38734 assertEquals(output, 1, outputLines.length);
38735 assertTrue(outputLines[0], matcher.matches());
38736
38737 assertEquals(output, "0", matcher.group(1));
38738 assertEquals(output, "a_ident@b.c", matcher.group(2));
38739 assertEquals(output, "Some Name", matcher.group(3));
38740
38741 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
38742 && GrouperClientWs.mostRecentRequest.contains("someValue"));
38743
38744
38745 } finally {
38746 System.setOut(systemOut);
38747 }
38748
38749 }
38750
38751
38752
38753
38754 public void testExternalSubjectDelete() throws Exception {
38755
38756
38757 GrouperSession grouperSession = GrouperSession.startRootSession();
38758
38759
38760 ExternalSubjectSave assignName = new ExternalSubjectSave(grouperSession).assignEmail("a@b.c")
38761 .assignIdentifier("a_ident@b.c").assignName("Some Name");
38762
38763 boolean hasJabber = StringUtils.equals(GrouperConfig.retrieveConfig().propertyValueString("externalSubjects.attributes.jabber.systemName"), "jabber");
38764
38765 if (hasJabber) {
38766 assignName.addAttribute("jabber", "a_jabber@b.c");
38767 }
38768 ExternalSubject externalSubject = assignName.save();
38769
38770
38771 PrintStream systemOut = System.out;
38772
38773 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38774 System.setOut(new PrintStream(baos));
38775
38776 try {
38777
38778 GrouperClient.main(GrouperClientUtils.splitTrim(
38779 "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c", " "));
38780 System.out.flush();
38781 String output = new String(baos.toByteArray());
38782
38783 System.setOut(systemOut);
38784
38785 String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
38786
38787 Pattern pattern = Pattern
38788 .compile("^Index (\\d+): success: T: code: ([A-Z_]+): identifier: (.+): name:\\s?(.*)$");
38789 Matcher matcher = pattern.matcher(outputLines[0]);
38790
38791 assertTrue(outputLines[0], matcher.matches());
38792
38793 assertEquals("0", matcher.group(1));
38794 assertEquals("SUCCESS", matcher.group(2));
38795 assertEquals("a_ident@b.c", matcher.group(3));
38796 assertEquals("Some Name", matcher.group(4));
38797
38798
38799
38800 baos = new ByteArrayOutputStream();
38801 System.setOut(new PrintStream(baos));
38802
38803 GrouperClient.main(GrouperClientUtils.splitTrim(
38804 "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c", " "));
38805 System.out.flush();
38806 output = new String(baos.toByteArray());
38807
38808 System.setOut(systemOut);
38809
38810 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38811
38812 matcher = pattern.matcher(outputLines[0]);
38813
38814 assertTrue(outputLines[0], matcher.matches());
38815
38816 assertEquals("0", matcher.group(1));
38817 assertEquals("SUCCESS_EXTERNAL_SUBJECT_NOT_FOUND", matcher.group(2));
38818 assertEquals("a_ident@b.c", matcher.group(3));
38819 assertTrue(matcher.group(4), StringUtils.isBlank(matcher.group(4)));
38820
38821
38822
38823 baos = new ByteArrayOutputStream();
38824 System.setOut(new PrintStream(baos));
38825
38826
38827 try {
38828 GrouperClient
38829 .main(GrouperClientUtils
38830 .splitTrim(
38831 "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --ousdfsdfate=${index}",
38832 " "));
38833 } catch (Exception e) {
38834 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
38835 }
38836 System.out.flush();
38837
38838 System.setOut(systemOut);
38839
38840
38841
38842 baos = new ByteArrayOutputStream();
38843 System.setOut(new PrintStream(baos));
38844
38845
38846 GrouperClient
38847 .main(GrouperClientUtils
38848 .splitTrim(
38849 "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --outputTemplate=${index}",
38850 " "));
38851
38852 System.out.flush();
38853
38854 output = new String(baos.toByteArray());
38855
38856 System.setOut(systemOut);
38857
38858 assertEquals("0", output);
38859
38860
38861
38862 baos = new ByteArrayOutputStream();
38863 System.setOut(new PrintStream(baos));
38864
38865 GrouperClient.main(GrouperClientUtils.splitTrim(
38866 "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --txType=NONE",
38867 " "));
38868 System.out.flush();
38869 output = new String(baos.toByteArray());
38870
38871 System.setOut(systemOut);
38872
38873 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38874
38875 matcher = pattern.matcher(outputLines[0]);
38876
38877 assertTrue(outputLines[0], matcher.matches());
38878
38879 assertEquals("0", matcher.group(1));
38880 assertEquals("SUCCESS_EXTERNAL_SUBJECT_NOT_FOUND", matcher.group(2));
38881 assertEquals("a_ident@b.c", matcher.group(3));
38882 assertTrue(matcher.group(4), StringUtils.isBlank(matcher.group(4)));
38883
38884 assertTrue(GrouperClientWs.mostRecentRequest,
38885 GrouperClientWs.mostRecentRequest.contains("txType")
38886 && GrouperClientWs.mostRecentRequest.contains("NONE"));
38887
38888
38889
38890 baos = new ByteArrayOutputStream();
38891 System.setOut(new PrintStream(baos));
38892
38893 GrouperClient
38894 .main(GrouperClientUtils
38895 .splitTrim(
38896 "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --paramName0=whatever --paramValue0=someValue",
38897 " "));
38898 System.out.flush();
38899 output = new String(baos.toByteArray());
38900
38901 System.setOut(systemOut);
38902
38903 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38904
38905 matcher = pattern.matcher(outputLines[0]);
38906
38907 assertTrue(outputLines[0], matcher.matches());
38908
38909 assertEquals("0", matcher.group(1));
38910 assertEquals("SUCCESS_EXTERNAL_SUBJECT_NOT_FOUND", matcher.group(2));
38911 assertEquals("a_ident@b.c", matcher.group(3));
38912 assertTrue(matcher.group(4), StringUtils.isBlank(matcher.group(4)));
38913
38914 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
38915 && GrouperClientWs.mostRecentRequest.contains("someValue"));
38916
38917 } finally {
38918 System.setOut(systemOut);
38919 }
38920
38921 }
38922
38923
38924
38925
38926 public void testExternalSubjectSave() throws Exception {
38927
38928 PrintStream systemOut = System.out;
38929
38930 ByteArrayOutputStream baos = new ByteArrayOutputStream();
38931 System.setOut(new PrintStream(baos));
38932 String output = null;
38933 String[] outputLines = null;
38934 Pattern pattern = null;
38935 Matcher matcher = null;
38936
38937 try {
38938
38939
38940
38941
38942 baos = new ByteArrayOutputStream();
38943 System.setOut(new PrintStream(baos));
38944
38945 GrouperClient.main(GrouperClientUtils.splitTrim(
38946 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d", " "));
38947 System.out.flush();
38948 output = new String(baos.toByteArray());
38949
38950 System.setOut(systemOut);
38951
38952 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38953
38954 pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): identifier: (.+): name: (.+)$");
38955 matcher = pattern.matcher(outputLines[0]);
38956
38957 assertTrue(outputLines[0], matcher.matches());
38958
38959 assertEquals("SUCCESS_INSERTED", matcher.group(1));
38960 assertEquals("b_ident@c.d", matcher.group(2));
38961 assertEquals("AnotherName", matcher.group(3));
38962
38963
38964
38965 baos = new ByteArrayOutputStream();
38966 System.setOut(new PrintStream(baos));
38967
38968 GrouperClient.main(GrouperClientUtils.splitTrim(
38969 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d", " "));
38970 System.out.flush();
38971 output = new String(baos.toByteArray());
38972
38973 System.setOut(systemOut);
38974
38975 outputLines = GrouperClientUtils.splitTrim(output, "\n");
38976
38977 matcher = pattern.matcher(outputLines[0]);
38978
38979 assertTrue(outputLines[0], matcher.matches());
38980
38981 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
38982 assertEquals("b_ident@c.d", matcher.group(2));
38983 assertEquals("AnotherName", matcher.group(3));
38984
38985
38986
38987 baos = new ByteArrayOutputStream();
38988 System.setOut(new PrintStream(baos));
38989
38990
38991 try {
38992 GrouperClient
38993 .main(GrouperClientUtils
38994 .splitTrim(
38995 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --ousdfsdfate=${index}",
38996 " "));
38997 } catch (Exception e) {
38998 assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
38999 }
39000 System.out.flush();
39001
39002 System.setOut(systemOut);
39003
39004
39005
39006 baos = new ByteArrayOutputStream();
39007 System.setOut(new PrintStream(baos));
39008
39009
39010 GrouperClient
39011 .main(GrouperClientUtils
39012 .splitTrim(
39013 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --outputTemplate=${index}",
39014 " "));
39015
39016 System.out.flush();
39017
39018 output = new String(baos.toByteArray());
39019
39020 System.setOut(systemOut);
39021
39022 assertEquals("0", output);
39023
39024
39025
39026 baos = new ByteArrayOutputStream();
39027 System.setOut(new PrintStream(baos));
39028
39029 GrouperClient.main(GrouperClientUtils.splitTrim(
39030 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --txType=NONE",
39031 " "));
39032
39033 System.out.flush();
39034 output = new String(baos.toByteArray());
39035
39036 System.setOut(systemOut);
39037
39038 outputLines = GrouperClientUtils.splitTrim(output, "\n");
39039
39040 matcher = pattern.matcher(outputLines[0]);
39041
39042 assertTrue(outputLines[0], matcher.matches());
39043
39044 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
39045 assertEquals("b_ident@c.d", matcher.group(2));
39046 assertEquals("AnotherName", matcher.group(3));
39047
39048 assertTrue(GrouperClientWs.mostRecentRequest,
39049 GrouperClientWs.mostRecentRequest.contains("txType")
39050 && GrouperClientWs.mostRecentRequest.contains("NONE")
39051 && !GrouperClientWs.mostRecentRequest
39052 .contains("includeGroupDetail"));
39053
39054
39055
39056 baos = new ByteArrayOutputStream();
39057 System.setOut(new PrintStream(baos));
39058
39059 GrouperClient.main(GrouperClientUtils.splitTrim(
39060 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --saveMode=UPDATE",
39061 " "));
39062 System.out.flush();
39063 output = new String(baos.toByteArray());
39064
39065 System.setOut(systemOut);
39066
39067 outputLines = GrouperClientUtils.splitTrim(output, "\n");
39068
39069 matcher = pattern.matcher(outputLines[0]);
39070
39071 assertTrue(outputLines[0], matcher.matches());
39072
39073 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
39074 assertEquals("b_ident@c.d", matcher.group(2));
39075 assertEquals("AnotherName", matcher.group(3));
39076
39077 assertTrue(GrouperClientWs.mostRecentRequest.contains("saveMode")
39078 && GrouperClientWs.mostRecentRequest.contains("UPDATE"));
39079
39080
39081
39082 baos = new ByteArrayOutputStream();
39083 System.setOut(new PrintStream(baos));
39084
39085 GrouperClient
39086 .main(GrouperClientUtils
39087 .splitTrim(
39088 "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --paramName0=whatever --paramValue0=someValue",
39089 " "));
39090 System.out.flush();
39091 output = new String(baos.toByteArray());
39092
39093 System.setOut(systemOut);
39094
39095 outputLines = GrouperClientUtils.splitTrim(output, "\n");
39096
39097 matcher = pattern.matcher(outputLines[0]);
39098
39099 assertTrue(outputLines[0], matcher.matches());
39100
39101 assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
39102 assertEquals("b_ident@c.d", matcher.group(2));
39103 assertEquals("AnotherName", matcher.group(3));
39104
39105 assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
39106 && GrouperClientWs.mostRecentRequest.contains("someValue"));
39107
39108 } finally {
39109 System.setOut(systemOut);
39110 }
39111
39112 }
39113
39114 }